From cbfd7abd3132ba29b663a6395c32dee2665a34d7 Mon Sep 17 00:00:00 2001 From: FuouM Date: Sat, 7 Mar 2026 11:21:31 +0700 Subject: [PATCH] initial support for matanyone2 --- README.md | 30 +- __init__.py | 4 +- constants.py | 1 + run.py | 90 ++ src/matanyone2/config/__init__.py | 1 + .../config/eval_matanyone_config.yaml | 33 + src/matanyone2/config/model/base.yaml | 49 + src/matanyone2/inference/__init__.py | 1 + .../inference/image_feature_store.py | 59 + src/matanyone2/inference/inference_core.py | 381 +++++ src/matanyone2/inference/kv_memory_store.py | 326 ++++ src/matanyone2/inference/memory_manager.py | 421 +++++ src/matanyone2/inference/object_info.py | 28 + src/matanyone2/inference/object_manager.py | 134 ++ src/matanyone2/model/aux_modules.py | 98 ++ src/matanyone2/model/big_modules.py | 402 +++++ src/matanyone2/model/channel_attn.py | 46 + src/matanyone2/model/group_modules.py | 139 ++ src/matanyone2/model/matanyone2.py | 364 +++++ src/matanyone2/model/modules.py | 173 +++ src/matanyone2/model/transformer/__init__.py | 1 + .../model/transformer/object_summarizer.py | 92 ++ .../model/transformer/object_transformer.py | 218 +++ .../model/transformer/positional_encoding.py | 93 ++ .../model/transformer/transformer_layers.py | 182 +++ src/matanyone2/model/utils/__init__.py | 4 + src/matanyone2/model/utils/memory_utils.py | 111 ++ .../model/utils/parameter_groups.py | 66 + src/matanyone2/model/utils/resnet.py | 186 +++ src/matanyone2/utils/__init__.py | 1 + src/matanyone2/utils/device.py | 47 + src/matanyone2/utils/get_default_model.py | 43 + src/matanyone2/utils/inference_utils.py | 69 + src/matanyone2/utils/tensor_utils.py | 71 + workflow/mat_anyone_preview_v2.png | Bin 0 -> 275202 bytes workflow/workflow_mat_anyone_v2.json | 1364 +++++++++++++++++ 36 files changed, 5326 insertions(+), 2 deletions(-) create mode 100644 src/matanyone2/config/__init__.py create mode 100644 src/matanyone2/config/eval_matanyone_config.yaml create mode 100644 src/matanyone2/config/model/base.yaml create mode 100644 src/matanyone2/inference/__init__.py create mode 100644 src/matanyone2/inference/image_feature_store.py create mode 100644 src/matanyone2/inference/inference_core.py create mode 100644 src/matanyone2/inference/kv_memory_store.py create mode 100644 src/matanyone2/inference/memory_manager.py create mode 100644 src/matanyone2/inference/object_info.py create mode 100644 src/matanyone2/inference/object_manager.py create mode 100644 src/matanyone2/model/aux_modules.py create mode 100644 src/matanyone2/model/big_modules.py create mode 100644 src/matanyone2/model/channel_attn.py create mode 100644 src/matanyone2/model/group_modules.py create mode 100644 src/matanyone2/model/matanyone2.py create mode 100644 src/matanyone2/model/modules.py create mode 100644 src/matanyone2/model/transformer/__init__.py create mode 100644 src/matanyone2/model/transformer/object_summarizer.py create mode 100644 src/matanyone2/model/transformer/object_transformer.py create mode 100644 src/matanyone2/model/transformer/positional_encoding.py create mode 100644 src/matanyone2/model/transformer/transformer_layers.py create mode 100644 src/matanyone2/model/utils/__init__.py create mode 100644 src/matanyone2/model/utils/memory_utils.py create mode 100644 src/matanyone2/model/utils/parameter_groups.py create mode 100644 src/matanyone2/model/utils/resnet.py create mode 100644 src/matanyone2/utils/__init__.py create mode 100644 src/matanyone2/utils/device.py create mode 100644 src/matanyone2/utils/get_default_model.py create mode 100644 src/matanyone2/utils/inference_utils.py create mode 100644 src/matanyone2/utils/tensor_utils.py create mode 100644 workflow/mat_anyone_preview_v2.png create mode 100644 workflow/workflow_mat_anyone_v2.json diff --git a/README.md b/README.md index 1277bf5..98d9baa 100644 --- a/README.md +++ b/README.md @@ -4,9 +4,17 @@ MatAnyone in ComfyUI (Remove background) Stable Video Matting with Consistent Memory Propagation: +Scaling Video Matting via a Learned Quality Evaluator: + Download `matanyone.pth` from -and place it in `checkpoint/matanyone.pth` +Download `matanyone2.pth` from + +```bash +checkpoint/ + matanyone.pth + matanyone2.pth +``` ## Workflow @@ -25,6 +33,19 @@ Inputs: Your input mask won't actually be in the final matte. Instead, the warmup process generate a new input mask, which is then propagated throughout the video. +### MatAnyone 2 Support + +The extension now includes the `MatAnyone2Video` node, which runs the improved MatAnyoneV2 model for higher-quality and more robust video matting. + +**Workflow V2**: [workflow/workflow_mat_anyone_v2.json](workflow/workflow_mat_anyone_v2.json) + +![matanyone_example](workflow/mat_anyone_preview_v2.png) +(Not a workflow-embedded image) + +Additional Inputs for V2: +- `r_erode` (optional): The radius for morphological erosion applied to the `foreground_mask` before processing (defaults to 0). Useful for refining rough masks. +- `r_dilate` (optional): The radius for morphological dilation applied to the `foreground_mask` before processing (defaults to 0). + ## Credit ```cite @@ -34,4 +55,11 @@ Your input mask won't actually be in the final matte. Instead, the warmup proces booktitle = {arXiv preprint arXiv:2501.14677}, year = {2025} } + +@InProceedings{yang2026matanyone2, + title = {{MatAnyone 2}: Scaling Video Matting via a Learned Quality Evaluator}, + author = {Yang, Peiqing and Zhou, Shangchen and Hao, Kai and Tao, Qingyi}, + booktitle = {CVPR}, + year = {2026} + } ``` diff --git a/__init__.py b/__init__.py index db9c5b7..510913f 100644 --- a/__init__.py +++ b/__init__.py @@ -1,12 +1,14 @@ -from .run import MatAnyoneVideo, SolidColorBatched +from .run import MatAnyoneVideo, MatAnyone2Video, SolidColorBatched NODE_CLASS_MAPPINGS = { "MatAnyone": MatAnyoneVideo, + "MatAnyone2": MatAnyone2Video, "SolidColorBatched": SolidColorBatched, } NODE_DISPLAY_NAME_MAPPINGS = { "MatAnyone": "MatAnyone", + "MatAnyone2": "MatAnyone2", "SolidColorBatched": "Solid Color Batched", } diff --git a/constants.py b/constants.py index ed6c451..d7c66b5 100644 --- a/constants.py +++ b/constants.py @@ -1 +1,2 @@ ckpt_path = "checkpoint/matanyone.pth" +ckpt_path_matanyone2 = "checkpoint/matanyone2.pth" diff --git a/run.py b/run.py index 4f98548..6579d6c 100644 --- a/run.py +++ b/run.py @@ -18,7 +18,12 @@ from .mat_anyone import ( get_matanyone_model, inference_matanyone, ) +from .mat_anyone2 import ( + get_matanyone2_model_cached, + inference_matanyone2, +) from .src.core.inference_core import InferenceCore +from .src.matanyone2.inference.inference_core import InferenceCore as InferenceCore2 class MatAnyoneVideo: @@ -91,6 +96,91 @@ class MatAnyoneVideo: ) +class MatAnyone2Video: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "src_video": ("IMAGE",), + "mask_frame": ( + "INT", + {"default": 0, "min": 0, "step": 1}, + ), + "n_warmup": ( + "INT", + {"default": 10, "min": 1, "step": 1}, + ), + }, + "optional": { + "foreground_mask": ("IMAGE",), + "foreground_MASK": ("MASK",), + "solid_color": ("IMAGE",), + "r_erode": ( + "INT", + {"default": 0, "min": 0, "step": 1}, + ), + "r_dilate": ( + "INT", + {"default": 0, "min": 0, "step": 1}, + ), + }, + } + + RETURN_TYPES = ( + "IMAGE", + "IMAGE", + ) + RETURN_NAMES = ( + "matte", + "green_screen", + ) + FUNCTION = "process" + CATEGORY = "MatAnyone" + + def process( + self, + src_video: torch.Tensor, + mask_frame: int, + n_warmup: int, + foreground_mask: torch.Tensor | None = None, + foreground_MASK: torch.Tensor | None = None, + solid_color: torch.Tensor | None = None, + r_erode: int = 0, + r_dilate: int = 0, + ): + mask = get_mask(foreground_mask, foreground_MASK) + src_video = src_video.permute(0, 3, 1, 2) # T C H W RGB, [0, 1] + + matanyone2 = get_matanyone2_model_cached() + processor = InferenceCore2(matanyone2, cfg=matanyone2.cfg) + phas = inference_matanyone2( + src_video, + mask, + processor, + mask_frame=mask_frame, + n_warmup=n_warmup, + r_erode=r_erode, + r_dilate=r_dilate, + ) + out_mask = torch.cat(phas).permute(0, 2, 3, 1) # T H W 1 -> T H W C + out_mask_rgb = out_mask.repeat(1, 1, 1, 3) + + gb = torch.empty( + 0, out_mask_rgb.shape[1], out_mask_rgb.shape[2], out_mask_rgb.shape[3] + ) + if solid_color is not None: + src_video_hwc = src_video.permute(0, 2, 3, 1).to(out_mask_rgb.device) + solid_color_batched = solid_color.repeat( + src_video_hwc.shape[0], 1, 1, 1 + ).to(out_mask_rgb.device) + gb = out_mask_rgb * src_video_hwc + (1 - out_mask_rgb) * solid_color_batched + + return ( + out_mask_rgb, + gb, + ) + + class SolidColorBatched: @classmethod def INPUT_TYPES(s): diff --git a/src/matanyone2/config/__init__.py b/src/matanyone2/config/__init__.py new file mode 100644 index 0000000..1f94ad5 --- /dev/null +++ b/src/matanyone2/config/__init__.py @@ -0,0 +1 @@ +"""MatAnyone2 config.""" diff --git a/src/matanyone2/config/eval_matanyone_config.yaml b/src/matanyone2/config/eval_matanyone_config.yaml new file mode 100644 index 0000000..c81bc10 --- /dev/null +++ b/src/matanyone2/config/eval_matanyone_config.yaml @@ -0,0 +1,33 @@ +defaults: + - _self_ + - model: base + - override hydra/job_logging: custom-no-rank.yaml + +hydra: + run: + dir: ../output/${exp_id}/${dataset} + output_subdir: ${now:%Y-%m-%d_%H-%M-%S}-hydra + +amp: False +weights: pretrained_models/matanyone2.pth +output_dir: null +flip_aug: False +max_internal_size: -1 +save_all: True +use_all_masks: False +use_long_term: False +mem_every: 5 +max_mem_frames: 5 +long_term: + count_usage: True + max_mem_frames: 10 + min_mem_frames: 5 + num_prototypes: 128 + max_num_tokens: 10000 + buffer_tokens: 2000 +top_k: 30 +stagger_updates: 5 +chunk_size: -1 +save_scores: False +save_aux: False +visualize: False diff --git a/src/matanyone2/config/model/base.yaml b/src/matanyone2/config/model/base.yaml new file mode 100644 index 0000000..d36999c --- /dev/null +++ b/src/matanyone2/config/model/base.yaml @@ -0,0 +1,49 @@ +pixel_mean: [0.485, 0.456, 0.406] +pixel_std: [0.229, 0.224, 0.225] +pixel_dim: 256 +key_dim: 64 +value_dim: 256 +sensory_dim: 256 +embed_dim: 256 +pixel_encoder: + type: resnet50 + ms_dims: [1024, 512, 256, 64, 3] +mask_encoder: + type: resnet18 + final_dim: 256 +pixel_pe_scale: 32 +pixel_pe_temperature: 128 +object_transformer: + embed_dim: ${model.embed_dim} + ff_dim: 2048 + num_heads: 8 + num_blocks: 3 + num_queries: 16 + read_from_pixel: + input_norm: False + input_add_pe: False + add_pe_to_qkv: [True, True, False] + read_from_past: + add_pe_to_qkv: [True, True, False] + read_from_memory: + add_pe_to_qkv: [True, True, False] + read_from_query: + add_pe_to_qkv: [True, True, False] + output_norm: False + query_self_attention: + add_pe_to_qkv: [True, True, False] + pixel_self_attention: + add_pe_to_qkv: [True, True, False] +object_summarizer: + embed_dim: ${model.object_transformer.embed_dim} + num_summaries: ${model.object_transformer.num_queries} + add_pe: True +aux_loss: + sensory: + enabled: True + weight: 0.01 + query: + enabled: True + weight: 0.01 +mask_decoder: + up_dims: [256, 128, 128, 64, 16] diff --git a/src/matanyone2/inference/__init__.py b/src/matanyone2/inference/__init__.py new file mode 100644 index 0000000..145089a --- /dev/null +++ b/src/matanyone2/inference/__init__.py @@ -0,0 +1 @@ +"""MatAnyone2 inference modules.""" diff --git a/src/matanyone2/inference/image_feature_store.py b/src/matanyone2/inference/image_feature_store.py new file mode 100644 index 0000000..918ac91 --- /dev/null +++ b/src/matanyone2/inference/image_feature_store.py @@ -0,0 +1,59 @@ +""" +Image feature cache for MatAnyone2 inference. +""" + +import warnings + +import torch + +from ..model.matanyone2 import MatAnyone2 + + +class ImageFeatureStore: + """Caches image features for reuse during inference.""" + + def __init__(self, network: MatAnyone2, no_warning: bool = False): + self.network = network + self._store = {} + self.no_warning = no_warning + + def _encode_feature(self, index: int, image: torch.Tensor, last_feats=None) -> None: + ms_features, pix_feat = self.network.encode_image(image, last_feats=last_feats) + key, shrinkage, selection = self.network.transform_key(ms_features[0]) + self._store[index] = (ms_features, pix_feat, key, shrinkage, selection) + + def get_all_features(self, images: torch.Tensor) -> tuple: + seq_length = images.shape[0] + ms_features, pix_feat = self.network.encode_image(images, seq_length) + key, shrinkage, selection = self.network.transform_key(ms_features[0]) + for index in range(seq_length): + self._store[index] = ( + [f[index].unsqueeze(0) for f in ms_features], + pix_feat[index].unsqueeze(0), + key[index].unsqueeze(0), + shrinkage[index].unsqueeze(0), + selection[index].unsqueeze(0), + ) + + def get_features(self, index: int, image: torch.Tensor, last_feats=None) -> tuple: + if index not in self._store: + self._encode_feature(index, image, last_feats) + return self._store[index][:2] + + def get_key(self, index: int, image: torch.Tensor, last_feats=None) -> tuple: + if index not in self._store: + self._encode_feature(index, image, last_feats) + return self._store[index][2:] + + def delete(self, index: int) -> None: + if index in self._store: + del self._store[index] + + def __len__(self): + return len(self._store) + + def __del__(self): + if len(self._store) > 0 and not self.no_warning: + warnings.warn( + "Leaking %s in the image feature store" % list(self._store.keys()) + ) diff --git a/src/matanyone2/inference/inference_core.py b/src/matanyone2/inference/inference_core.py new file mode 100644 index 0000000..91152dc --- /dev/null +++ b/src/matanyone2/inference/inference_core.py @@ -0,0 +1,381 @@ +""" +Inference core for MatAnyone2. +""" + +import logging +from typing import Iterable, List, Optional, Union + +import numpy as np +import torch +import torch.nn.functional as F +from omegaconf import DictConfig + +from ..model.matanyone2 import MatAnyone2 +from ..utils.device import get_default_device, safe_autocast_decorator +from ..utils.tensor_utils import aggregate, pad_divide_by, unpad +from .image_feature_store import ImageFeatureStore +from .memory_manager import MemoryManager +from .object_manager import ObjectManager + +log = logging.getLogger() + + +class InferenceCore: + """Core inference logic for MatAnyone2.""" + + def __init__( + self, + network: MatAnyone2, + cfg: Optional[DictConfig] = None, + *, + image_feature_store: ImageFeatureStore = None, + device: Optional[Union[str, torch.device]] = None, + ): + if device is None: + device = get_default_device() + self.device = device + network.to(device) + network.eval() + self.network = network + cfg = cfg if cfg is not None else network.cfg + self.cfg = cfg + self.mem_every = cfg.mem_every + stagger_updates = cfg.stagger_updates + self.chunk_size = cfg.chunk_size + self.save_aux = cfg.save_aux + self.max_internal_size = cfg.max_internal_size + self.flip_aug = cfg.flip_aug + + self.curr_ti = -1 + self.last_mem_ti = 0 + if stagger_updates >= self.mem_every: + self.stagger_ti = set(range(1, self.mem_every + 1)) + else: + self.stagger_ti = set( + np.round(np.linspace(1, self.mem_every, stagger_updates)).astype(int) + ) + self.object_manager = ObjectManager() + self.memory = MemoryManager(cfg=cfg, object_manager=self.object_manager) + + if image_feature_store is None: + self.image_feature_store = ImageFeatureStore(self.network) + else: + self.image_feature_store = image_feature_store + + self.last_mask = None + self.last_pix_feat = None + self.last_msk_value = None + + def clear_memory(self) -> None: + self.curr_ti = -1 + self.last_mem_ti = 0 + self.memory = MemoryManager(cfg=self.cfg, object_manager=self.object_manager) + + def clear_non_permanent_memory(self) -> None: + self.curr_ti = -1 + self.last_mem_ti = 0 + self.memory.clear_non_permanent_memory() + + def clear_sensory_memory(self) -> None: + self.curr_ti = -1 + self.last_mem_ti = 0 + self.memory.clear_sensory_memory() + + def update_config(self, cfg) -> None: + self.mem_every = cfg["mem_every"] + self.memory.update_config(cfg) + + def clear_temp_mem(self) -> None: + self.memory.clear_work_mem() + self.memory.clear_obj_mem() + + def _add_memory( + self, + image: torch.Tensor, + pix_feat: torch.Tensor, + prob: torch.Tensor, + key: torch.Tensor, + shrinkage: torch.Tensor, + selection: torch.Tensor, + *, + is_deep_update: bool = True, + force_permanent: bool = False, + ) -> None: + if prob.shape[1] == 0: + log.warning("Trying to add an empty object mask to memory!") + return + + as_permanent = "all" if force_permanent else "first" + self.memory.initialize_sensory_if_needed(key, self.object_manager.all_obj_ids) + msk_value, sensory, obj_value, _ = self.network.encode_mask( + image, + pix_feat, + self.memory.get_sensory(self.object_manager.all_obj_ids), + prob, + deep_update=is_deep_update, + chunk_size=self.chunk_size, + need_weights=self.save_aux, + ) + self.memory.add_memory( + key, + shrinkage, + msk_value, + obj_value, + self.object_manager.all_obj_ids, + selection=selection, + as_permanent=as_permanent, + ) + self.last_mem_ti = self.curr_ti + if is_deep_update: + self.memory.update_sensory(sensory, self.object_manager.all_obj_ids) + self.last_msk_value = msk_value + + def _segment( + self, + key: torch.Tensor, + selection: torch.Tensor, + pix_feat: torch.Tensor, + ms_features: Iterable[torch.Tensor], + update_sensory: bool = True, + ) -> torch.Tensor: + bs = key.shape[0] + if not self.memory.engaged: + log.warning("Trying to segment without any memory!") + return torch.zeros( + (1, key.shape[-2] * 16, key.shape[-1] * 16), + device=key.device, + dtype=key.dtype, + ) + + uncert_output = None + if self.curr_ti == 0: + memory_readout = self.memory.read_first_frame( + self.last_msk_value, + pix_feat, + self.last_mask, + self.network, + uncert_output=uncert_output, + ) + else: + memory_readout = self.memory.read( + pix_feat, + key, + selection, + self.last_mask, + self.network, + uncert_output=uncert_output, + last_msk_value=self.last_msk_value, + ti=self.curr_ti, + last_pix_feat=self.last_pix_feat, + last_pred_mask=self.last_mask, + ) + memory_readout = self.object_manager.realize_dict(memory_readout) + + sensory, _, pred_prob_with_bg = self.network.segment( + ms_features, + memory_readout, + self.memory.get_sensory(self.object_manager.all_obj_ids), + chunk_size=self.chunk_size, + update_sensory=update_sensory, + ) + if self.flip_aug: + pred_prob_with_bg = ( + pred_prob_with_bg[0] + torch.flip(pred_prob_with_bg[1], dims=[-1]) + ) / 2 + else: + pred_prob_with_bg = pred_prob_with_bg[0] + if update_sensory: + self.memory.update_sensory(sensory, self.object_manager.all_obj_ids) + return pred_prob_with_bg + + @torch.inference_mode() + @safe_autocast_decorator() + def step( + self, + image: torch.Tensor, + mask: Optional[torch.Tensor] = None, + objects: Optional[List[int]] = None, + *, + idx_mask: bool = False, + end: bool = False, + delete_buffer: bool = True, + force_permanent: bool = False, + matting: bool = True, + first_frame_pred: bool = False, + ) -> torch.Tensor: + if objects is None and mask is not None: + assert not idx_mask + objects = list(range(1, mask.shape[0] + 1)) + + resize_needed = False + if self.max_internal_size > 0: + h, w = image.shape[-2:] + min_side = min(h, w) + if min_side > self.max_internal_size: + resize_needed = True + new_h = int(h / min_side * self.max_internal_size) + new_w = int(w / min_side * self.max_internal_size) + image = F.interpolate( + image.unsqueeze(0), + size=(new_h, new_w), + mode="bilinear", + align_corners=False, + )[0] + if mask is not None: + if idx_mask: + mask = ( + F.interpolate( + mask.unsqueeze(0).unsqueeze(0).float(), + size=(new_h, new_w), + mode="nearest-exact", + align_corners=False, + )[0, 0] + .round() + .long() + ) + else: + mask = F.interpolate( + mask.unsqueeze(0), + size=(new_h, new_w), + mode="bilinear", + align_corners=False, + )[0] + + self.curr_ti += 1 + + image, self.pad = pad_divide_by(image, 16) + image = image.unsqueeze(0) + if self.flip_aug: + image = torch.cat([image, torch.flip(image, dims=[-1])], dim=0) + + is_mem_frame = ( + (self.curr_ti - self.last_mem_ti >= self.mem_every) or mask is not None + ) and (not end) + need_segment = (mask is None) or ( + self.object_manager.num_obj > 0 and not self.object_manager.has_all(objects) + ) + update_sensory = ((self.curr_ti - self.last_mem_ti) in self.stagger_ti) and ( + not end + ) + + if first_frame_pred: + self.curr_ti = 0 + self.last_mem_ti = 0 + is_mem_frame = True + need_segment = True + update_sensory = True + + ms_feat, pix_feat = self.image_feature_store.get_features(self.curr_ti, image) + key, shrinkage, selection = self.image_feature_store.get_key( + self.curr_ti, image + ) + + if need_segment: + pred_prob_with_bg = self._segment( + key, selection, pix_feat, ms_feat, update_sensory=update_sensory + ) + + if mask is not None: + corresponding_tmp_ids, _ = self.object_manager.add_new_objects(objects) + mask, _ = pad_divide_by(mask, 16) + if need_segment: + pred_prob_no_bg = pred_prob_with_bg[1:] + if idx_mask: + pred_prob_no_bg[:, mask > 0] = 0 + else: + pred_prob_no_bg[:, mask.max(0) > 0.5] = 0 + new_masks = [] + for mask_id, tmp_id in enumerate(corresponding_tmp_ids): + if idx_mask: + this_mask = (mask == objects[mask_id]).type_as(pred_prob_no_bg) + else: + this_mask = mask[tmp_id] + if tmp_id > pred_prob_no_bg.shape[0]: + new_masks.append(this_mask.unsqueeze(0)) + else: + pred_prob_no_bg[tmp_id - 1] = this_mask + mask = torch.cat([pred_prob_no_bg, *new_masks], dim=0) + elif idx_mask: + if len(objects) == 0: + if delete_buffer: + self.image_feature_store.delete(self.curr_ti) + log.warning("Trying to insert an empty mask as memory!") + return torch.zeros( + (1, key.shape[-2] * 16, key.shape[-1] * 16), + device=key.device, + dtype=key.dtype, + ) + mask = torch.stack( + [ + mask == objects[mask_id] + for mask_id, _ in enumerate(corresponding_tmp_ids) + ], + dim=0, + ) + if matting: + mask = mask.unsqueeze(0).float() / 255.0 + pred_prob_with_bg = torch.cat([1 - mask, mask], 0) + else: + pred_prob_with_bg = aggregate(mask, dim=0) + pred_prob_with_bg = torch.softmax(pred_prob_with_bg, dim=0) + + self.last_mask = pred_prob_with_bg[1:].unsqueeze(0) + if self.flip_aug: + self.last_mask = torch.cat( + [ + self.last_mask, + torch.flip(self.last_mask, dims=[-1]), + ], + dim=0, + ) + self.last_pix_feat = pix_feat + + if is_mem_frame or force_permanent: + if first_frame_pred: + self.clear_temp_mem() + self._add_memory( + image, + pix_feat, + self.last_mask, + key, + shrinkage, + selection, + force_permanent=force_permanent, + is_deep_update=True, + ) + else: + msk_value, _, _, _ = self.network.encode_mask( + image, + pix_feat, + self.memory.get_sensory(self.object_manager.all_obj_ids), + self.last_mask, + deep_update=False, + chunk_size=self.chunk_size, + need_weights=self.save_aux, + ) + self.last_msk_value = msk_value + + if delete_buffer: + self.image_feature_store.delete(self.curr_ti) + + output_prob = unpad(pred_prob_with_bg, self.pad) + if resize_needed: + output_prob = F.interpolate( + output_prob.unsqueeze(0), + size=(h, w), + mode="bilinear", + align_corners=False, + )[0] + + return output_prob + + def output_prob_to_mask( + self, output_prob: torch.Tensor, matting: bool = True + ) -> torch.Tensor: + if matting: + return output_prob[1:].squeeze(0) + mask = torch.argmax(output_prob, dim=0) + new_mask = torch.zeros_like(mask) + for tmp_id, obj in self.object_manager.tmp_id_to_obj.items(): + new_mask[mask == tmp_id] = obj.id + return new_mask diff --git a/src/matanyone2/inference/kv_memory_store.py b/src/matanyone2/inference/kv_memory_store.py new file mode 100644 index 0000000..3108f6f --- /dev/null +++ b/src/matanyone2/inference/kv_memory_store.py @@ -0,0 +1,326 @@ +""" +Key-value memory store for MatAnyone2 inference. +""" + +from collections import defaultdict +from typing import Dict, List, Literal, Optional + +import torch + + +def _add_last_dim(dictionary, key, new_value, prepend=False): + """Appends or prepends a new value to the last dimension of a tensor.""" + if key in dictionary: + dictionary[key] = torch.cat([dictionary[key], new_value], -1) + else: + dictionary[key] = new_value + + +class KeyValueMemoryStore: + """Key-value memory store for working and long-term memory.""" + + def __init__(self, save_selection: bool = False, save_usage: bool = False): + self.save_selection = save_selection + self.save_usage = save_usage + self.global_bucket_id = 0 + self.buckets: Dict[int, List[int]] = {} + self.k: Dict[int, torch.Tensor] = {} + self.v: Dict[int, torch.Tensor] = {} + self.perm_end_pt: Dict[int, int] = defaultdict(int) + self.s = {} + if self.save_selection: + self.e = {} + if self.save_usage: + self.use_cnt = {} + self.life_cnt = {} + + @property + def key(self): + return self.k + + @property + def value(self): + return self.v + + @property + def shrinkage(self): + return self.s + + @property + def selection(self): + return self.e if self.save_selection else None + + def add( + self, + key: torch.Tensor, + values: Dict[int, torch.Tensor], + shrinkage: torch.Tensor, + selection: Optional[torch.Tensor] = None, + supposed_bucket_id: int = -1, + as_permanent: Literal["no", "first", "all"] = "no", + ) -> None: + bs = key.shape[0] + ne = key.shape[-1] + assert len(key.shape) == 3 + assert len(shrinkage.shape) == 3 + assert not self.save_selection or ( + selection is not None and len(selection.shape) == 3 + ) + assert as_permanent in ["no", "first", "all"] + + if supposed_bucket_id >= 0: + enabled_buckets = [supposed_bucket_id] + bucket_exist = supposed_bucket_id in self.buckets + for obj, value in values.items(): + if bucket_exist: + assert obj in self.v + assert obj in self.buckets[supposed_bucket_id] + _add_last_dim(self.v, obj, value, prepend=(as_permanent == "all")) + else: + assert obj not in self.v + self.v[obj] = value + self.buckets[supposed_bucket_id] = list(values.keys()) + else: + new_bucket_id = None + enabled_buckets = set() + for obj, value in values.items(): + assert len(value.shape) == 3 + if obj in self.v: + _add_last_dim(self.v, obj, value, prepend=(as_permanent == "all")) + bucket_used = [ + bid for bid, oids in self.buckets.items() if obj in oids + ] + assert len(bucket_used) == 1 + enabled_buckets.add(bucket_used[0]) + else: + self.v[obj] = value + if new_bucket_id is None: + new_bucket_id = self.global_bucket_id + self.global_bucket_id += 1 + self.buckets[new_bucket_id] = [] + self.buckets[new_bucket_id].append(obj) + enabled_buckets.add(new_bucket_id) + + add_as_permanent = {} + for bucket_id in enabled_buckets: + add_as_permanent[bucket_id] = False + if as_permanent == "all": + self.perm_end_pt[bucket_id] += ne + add_as_permanent[bucket_id] = True + elif as_permanent == "first": + if self.perm_end_pt[bucket_id] == 0: + self.perm_end_pt[bucket_id] = ne + add_as_permanent[bucket_id] = True + + if self.save_usage and as_permanent != "all": + new_count = torch.zeros((bs, ne), device=key.device, dtype=torch.float32) + new_life = ( + torch.zeros((bs, ne), device=key.device, dtype=torch.float32) + 1e-7 + ) + + for bucket_id in self.buckets: + if bucket_id not in enabled_buckets: + continue + _add_last_dim(self.k, bucket_id, key, prepend=add_as_permanent[bucket_id]) + _add_last_dim( + self.s, bucket_id, shrinkage, prepend=add_as_permanent[bucket_id] + ) + if not add_as_permanent[bucket_id]: + if self.save_selection and selection is not None: + _add_last_dim(self.e, bucket_id, selection) + if self.save_usage: + _add_last_dim(self.use_cnt, bucket_id, new_count) + _add_last_dim(self.life_cnt, bucket_id, new_life) + + def update_bucket_usage(self, bucket_id: int, usage: torch.Tensor) -> None: + if not self.save_usage: + return + usage = usage[:, self.perm_end_pt[bucket_id] :] + if usage.shape[-1] == 0: + return + self.use_cnt[bucket_id] += usage.view_as(self.use_cnt[bucket_id]) + self.life_cnt[bucket_id] += 1 + + def sieve_by_range( + self, bucket_id: int, start: int, end: int, min_size: int + ) -> None: + assert start >= 0 + assert end <= 0 + object_ids = self.buckets[bucket_id] + bucket_num_elements = self.k[bucket_id].shape[-1] - self.perm_end_pt[bucket_id] + if bucket_num_elements <= min_size: + return + if end == 0: + end = self.k[bucket_id].shape[-1] + 1 + p_size = self.perm_end_pt[bucket_id] + start = start + p_size + + k = self.k[bucket_id] + s = self.s[bucket_id] + self.k[bucket_id] = torch.cat([k[:, :, :start], k[:, :, end:]], -1) + self.s[bucket_id] = torch.cat([s[:, :, :start], s[:, :, end:]], -1) + if self.save_selection: + e = self.e[bucket_id] + self.e[bucket_id] = torch.cat( + [e[:, :, : start - p_size], e[:, :, end:]], -1 + ) + if self.save_usage: + use_cnt = self.use_cnt[bucket_id] + life_cnt = self.life_cnt[bucket_id] + self.use_cnt[bucket_id] = torch.cat( + [use_cnt[:, : start - p_size], use_cnt[:, end:]], -1 + ) + self.life_cnt[bucket_id] = torch.cat( + [life_cnt[:, : start - p_size], life_cnt[:, end:]], -1 + ) + for obj_id in object_ids: + v = self.v[obj_id] + self.v[obj_id] = torch.cat([v[:, :, :start], v[:, :, end:]], -1) + + def remove_old_memory(self, bucket_id: int, max_len: int) -> None: + self.sieve_by_range(bucket_id, 0, -max_len, max_len) + + def remove_obsolete_features(self, bucket_id: int, max_size: int) -> None: + object_ids = self.buckets[bucket_id] + assert self.perm_end_pt[bucket_id] == 0 + usage = self.get_usage(bucket_id) + bs = usage.shape[0] + survivals = [] + for bi in range(bs): + _, survived = torch.topk(usage[bi], k=max_size) + survivals.append(survived.flatten()) + self.k[bucket_id] = torch.stack( + [ + self.k[bucket_id][bi, :, survived] + for bi, survived in enumerate(survivals) + ], + 0, + ) + self.s[bucket_id] = torch.stack( + [ + self.s[bucket_id][bi, :, survived] + for bi, survived in enumerate(survivals) + ], + 0, + ) + if self.save_selection: + self.e[bucket_id] = torch.stack( + [ + self.e[bucket_id][bi, :, survived] + for bi, survived in enumerate(survivals) + ], + 0, + ) + for obj_id in object_ids: + self.v[obj_id] = torch.stack( + [ + self.v[obj_id][bi, :, survived] + for bi, survived in enumerate(survivals) + ], + 0, + ) + self.use_cnt[bucket_id] = torch.stack( + [ + self.use_cnt[bucket_id][bi, survived] + for bi, survived in enumerate(survivals) + ], + 0, + ) + self.life_cnt[bucket_id] = torch.stack( + [ + self.life_cnt[bucket_id][bi, survived] + for bi, survived in enumerate(survivals) + ], + 0, + ) + + def get_usage(self, bucket_id: int) -> torch.Tensor: + if not self.save_usage: + raise RuntimeError("Usage not tracked") + return self.use_cnt[bucket_id] / self.life_cnt[bucket_id] + + def get_all_sliced(self, bucket_id: int, start: int, end: int) -> tuple: + assert start >= 0 + assert end <= 0 + p_size = self.perm_end_pt[bucket_id] + start = start + p_size + if end == 0: + k = self.k[bucket_id][:, :, start:] + sk = self.s[bucket_id][:, :, start:] + ek = ( + self.e[bucket_id][:, :, start - p_size :] + if self.save_selection + else None + ) + value = { + obj_id: self.v[obj_id][:, :, start:] + for obj_id in self.buckets[bucket_id] + } + usage = ( + self.get_usage(bucket_id)[:, start - p_size :] + if self.save_usage + else None + ) + else: + k = self.k[bucket_id][:, :, start:end] + sk = self.s[bucket_id][:, :, start:end] + ek = ( + self.e[bucket_id][:, :, start - p_size : end] + if self.save_selection + else None + ) + value = { + obj_id: self.v[obj_id][:, :, start:end] + for obj_id in self.buckets[bucket_id] + } + usage = ( + self.get_usage(bucket_id)[:, start - p_size : end] + if self.save_usage + else None + ) + return k, sk, ek, value, usage + + def purge_except(self, obj_keep_idx: List[int]) -> None: + obj_keep_idx = set(obj_keep_idx) + buckets_to_remove = [] + for bucket_id, object_ids in self.buckets.items(): + self.buckets[bucket_id] = [oid for oid in object_ids if oid in obj_keep_idx] + if len(self.buckets[bucket_id]) == 0: + buckets_to_remove.append(bucket_id) + self.v = {k: v for k, v in self.v.items() if k in obj_keep_idx} + for bucket_id in buckets_to_remove: + del self.buckets[bucket_id] + del self.k[bucket_id] + del self.s[bucket_id] + if self.save_selection: + del self.e[bucket_id] + if self.save_usage: + del self.use_cnt[bucket_id] + del self.life_cnt[bucket_id] + + def clear_non_permanent_memory(self) -> None: + for bucket_id in self.buckets: + self.sieve_by_range(bucket_id, 0, 0, 0) + + def get_v_size(self, obj_id: int) -> int: + return self.v[obj_id].shape[-1] + + def size(self, bucket_id: int) -> int: + if bucket_id not in self.k: + return 0 + return self.k[bucket_id].shape[-1] + + def perm_size(self, bucket_id: int) -> int: + return self.perm_end_pt[bucket_id] + + def non_perm_size(self, bucket_id: int) -> int: + return self.size(bucket_id) - self.perm_size(bucket_id) + + def engaged(self, bucket_id: Optional[int] = None) -> bool: + if bucket_id is None: + return len(self.buckets) > 0 + return bucket_id in self.buckets + + @property + def num_objects(self) -> int: + return len(self.v) diff --git a/src/matanyone2/inference/memory_manager.py b/src/matanyone2/inference/memory_manager.py new file mode 100644 index 0000000..c8f3efe --- /dev/null +++ b/src/matanyone2/inference/memory_manager.py @@ -0,0 +1,421 @@ +""" +Memory manager for MatAnyone2 inference. +""" + +import logging +from typing import Dict, List + +import torch +from omegaconf import DictConfig + +from ..model.matanyone2 import MatAnyone2 +from ..model.utils.memory_utils import do_softmax, get_similarity +from .kv_memory_store import KeyValueMemoryStore +from .object_manager import ObjectManager + +log = logging.getLogger() + + +class MemoryManager: + """Manages working and long-term memory for MatAnyone2.""" + + def __init__(self, cfg: DictConfig, object_manager: ObjectManager): + self.object_manager = object_manager + self.sensory_dim = cfg.model.sensory_dim + self.top_k = cfg.top_k + self.chunk_size = cfg.chunk_size + self.save_aux = cfg.save_aux + self.use_long_term = cfg.use_long_term + self.count_long_term_usage = cfg.long_term.count_usage + + if self.use_long_term: + self.max_mem_frames = cfg.long_term.max_mem_frames - 1 + self.min_mem_frames = cfg.long_term.min_mem_frames - 1 + self.num_prototypes = cfg.long_term.num_prototypes + self.max_long_tokens = cfg.long_term.max_num_tokens + self.buffer_tokens = cfg.long_term.buffer_tokens + else: + self.max_mem_frames = cfg.max_mem_frames - 1 + + self.CK = self.CV = None + self.H = self.W = None + self.sensory = {} + self.obj_v = {} + + self.work_mem = KeyValueMemoryStore( + save_selection=self.use_long_term, + save_usage=self.use_long_term, + ) + if self.use_long_term: + self.long_mem = KeyValueMemoryStore(save_usage=self.count_long_term_usage) + + self.config_stale = True + self.engaged = False + + def update_config(self, cfg: DictConfig) -> None: + self.config_stale = True + self.top_k = cfg["top_k"] + assert self.use_long_term == cfg.use_long_term + assert self.count_long_term_usage == cfg.long_term.count_usage + if self.use_long_term: + self.max_mem_frames = cfg.long_term.max_mem_frames - 1 + self.min_mem_frames = cfg.long_term.min_mem_frames - 1 + self.num_prototypes = cfg.long_term.num_prototypes + self.max_long_tokens = cfg.long_term.max_num_tokens + self.buffer_tokens = cfg.long_term.buffer_tokens + else: + self.max_mem_frames = cfg.max_mem_frames - 1 + + def _readout(self, affinity, v, uncert_mask=None) -> torch.Tensor: + if len(v.shape) == 3: + if uncert_mask is not None: + return v @ affinity * uncert_mask + return v @ affinity + bs, num_objects, C, N = v.shape + v = v.view(bs, num_objects * C, N) + out = v @ affinity + if uncert_mask is not None: + uncert_mask = uncert_mask.flatten(start_dim=2).expand(-1, C, -1) + out = out * uncert_mask + return out.view(bs, num_objects, C, -1) + + def _get_mask_by_ids(self, mask: torch.Tensor, obj_ids: List[int]) -> torch.Tensor: + return mask[ + :, + [self.object_manager.find_tmp_by_id(obj) - 1 for obj in obj_ids], + ] + + def _get_sensory_by_ids(self, obj_ids: List[int]) -> torch.Tensor: + return torch.stack([self.sensory[obj] for obj in obj_ids], dim=1) + + def _get_object_mem_by_ids(self, obj_ids: List[int]) -> torch.Tensor: + return torch.stack([self.obj_v[obj] for obj in obj_ids], dim=1) + + def _get_visual_values_by_ids(self, obj_ids: List[int]) -> torch.Tensor: + value = torch.stack([self.work_mem.value[obj] for obj in obj_ids], dim=1) + if self.use_long_term and obj_ids[0] in self.long_mem.value: + lt_value = torch.stack([self.long_mem.value[obj] for obj in obj_ids], dim=1) + value = torch.cat([lt_value, value], dim=-1) + return value + + def read_first_frame( + self, + last_msk_value: torch.Tensor, + pix_feat: torch.Tensor, + last_mask: torch.Tensor, + network: MatAnyone2, + uncert_output=None, + ) -> Dict[int, torch.Tensor]: + bs = pix_feat.shape[0] + all_readout_mem = {} + buckets = self.work_mem.buckets + + for bucket_id, bucket in buckets.items(): + object_chunks = ( + [bucket] + if self.chunk_size < 1 + else [ + bucket[i : i + self.chunk_size] + for i in range(0, len(bucket), self.chunk_size) + ] + ) + for objects in object_chunks: + this_sensory = self._get_sensory_by_ids(objects) + this_last_mask = self._get_mask_by_ids(last_mask, objects) + pixel_readout = network.pixel_fusion( + pix_feat, last_msk_value, this_sensory, this_last_mask + ) + this_obj_mem = self._get_object_mem_by_ids(objects).unsqueeze(2) + readout_memory, aux_features = network.readout_query( + pixel_readout, this_obj_mem + ) + for i, obj in enumerate(objects): + all_readout_mem[obj] = readout_memory[:, i] + if self.save_aux: + self.aux = { + "q_logits": (aux_features["logits"] if aux_features else None), + } + return all_readout_mem + + def read( + self, + pix_feat: torch.Tensor, + query_key: torch.Tensor, + selection: torch.Tensor, + last_mask: torch.Tensor, + network: MatAnyone2, + uncert_output=None, + last_msk_value=None, + ti=None, + last_pix_feat=None, + last_pred_mask=None, + ) -> Dict[int, torch.Tensor]: + h, w = pix_feat.shape[-2:] + bs = pix_feat.shape[0] + uncert_mask = uncert_output["mask"] if uncert_output is not None else None + query_key = query_key.flatten(start_dim=2) + selection = selection.flatten(start_dim=2) + + all_readout_mem = {} + buckets = self.work_mem.buckets + + for bucket_id, bucket in buckets.items(): + if self.use_long_term and self.long_mem.engaged(bucket_id): + long_mem_size = self.long_mem.size(bucket_id) + memory_key = torch.cat( + [ + self.long_mem.key[bucket_id], + self.work_mem.key[bucket_id], + ], + -1, + ) + shrinkage = torch.cat( + [ + self.long_mem.shrinkage[bucket_id], + self.work_mem.shrinkage[bucket_id], + ], + -1, + ) + similarity = get_similarity(memory_key, shrinkage, query_key, selection) + affinity, usage = do_softmax( + similarity, + top_k=self.top_k, + inplace=True, + return_usage=True, + ) + work_usage = usage[:, long_mem_size:] + self.work_mem.update_bucket_usage(bucket_id, work_usage) + if self.count_long_term_usage: + long_usage = usage[:, :long_mem_size] + self.long_mem.update_bucket_usage(bucket_id, long_usage) + else: + memory_key = self.work_mem.key[bucket_id] + shrinkage = self.work_mem.shrinkage[bucket_id] + similarity = get_similarity( + memory_key, + shrinkage, + query_key, + selection, + uncert_mask=uncert_mask, + ) + if self.use_long_term: + affinity, usage = do_softmax( + similarity, + top_k=self.top_k, + inplace=True, + return_usage=True, + ) + self.work_mem.update_bucket_usage(bucket_id, usage) + else: + affinity = do_softmax(similarity, top_k=self.top_k, inplace=True) + + object_chunks = ( + [bucket] + if self.chunk_size < 1 + else [ + bucket[i : i + self.chunk_size] + for i in range(0, len(bucket), self.chunk_size) + ] + ) + for objects in object_chunks: + this_sensory = self._get_sensory_by_ids(objects) + this_last_mask = self._get_mask_by_ids(last_mask, objects) + this_msk_value = self._get_visual_values_by_ids(objects) + visual_readout = self._readout( + affinity, this_msk_value, uncert_mask + ).view(bs, len(objects), self.CV, h, w) + + if ( + last_msk_value is not None + and last_pix_feat is not None + and last_pred_mask is not None + ): + uncert_output = network.pred_uncertainty( + last_pix_feat, + pix_feat, + last_pred_mask, + visual_readout[:, 0] - last_msk_value[:, 0], + ) + uncert_prob = uncert_output["prob"].unsqueeze(1) + visual_readout = visual_readout * uncert_prob + last_msk_value * ( + 1 - uncert_prob + ) + + pixel_readout = network.pixel_fusion( + pix_feat, visual_readout, this_sensory, this_last_mask + ) + this_obj_mem = self._get_object_mem_by_ids(objects).unsqueeze(2) + readout_memory, aux_features = network.readout_query( + pixel_readout, this_obj_mem + ) + for i, obj in enumerate(objects): + all_readout_mem[obj] = readout_memory[:, i] + if self.save_aux: + self.aux = { + "q_logits": (aux_features["logits"] if aux_features else None), + } + return all_readout_mem + + def add_memory( + self, + key: torch.Tensor, + shrinkage: torch.Tensor, + msk_value: torch.Tensor, + obj_value: torch.Tensor, + objects: List[int], + selection: torch.Tensor = None, + *, + as_permanent: bool = False, + ) -> None: + bs = key.shape[0] + self.engaged = True + if self.H is None or self.config_stale: + self.config_stale = False + self.H, self.W = msk_value.shape[-2:] + self.HW = self.H * self.W + self.max_work_tokens = self.max_mem_frames * self.HW + if self.use_long_term: + self.min_work_tokens = self.min_mem_frames * self.HW + + key = key.flatten(start_dim=2) + shrinkage = shrinkage.flatten(start_dim=2) + self.CK = key.shape[1] + msk_value = msk_value.flatten(start_dim=3) + self.CV = msk_value.shape[2] + if selection is not None: + selection = selection.flatten(start_dim=2) + + for obj_id, obj in enumerate(objects): + if obj in self.obj_v: + last_acc = self.obj_v[obj][:, :, -1] + new_acc = last_acc + obj_value[:, obj_id, :, -1] + self.obj_v[obj][:, :, :-1] = ( + self.obj_v[obj][:, :, :-1] + obj_value[:, obj_id, :, :-1] + ) + self.obj_v[obj][:, :, -1] = new_acc + else: + self.obj_v[obj] = obj_value[:, obj_id] + + msk_values = {obj: msk_value[:, obj_id] for obj_id, obj in enumerate(objects)} + self.work_mem.add( + key, + msk_values, + shrinkage, + selection=selection, + as_permanent=as_permanent, + ) + + for bucket_id in list(self.work_mem.buckets.keys()): + if self.use_long_term: + if self.work_mem.non_perm_size(bucket_id) >= self.max_work_tokens: + if self.long_mem.non_perm_size(bucket_id) >= ( + self.max_long_tokens - self.num_prototypes + ): + self.long_mem.remove_obsolete_features( + bucket_id, + self.max_long_tokens + - self.num_prototypes + - self.buffer_tokens, + ) + self.compress_features(bucket_id) + else: + self.work_mem.remove_old_memory(bucket_id, self.max_work_tokens) + + def purge_except(self, obj_keep_idx: List[int]) -> None: + self.work_mem.purge_except(obj_keep_idx) + if self.use_long_term and self.long_mem.engaged(): + self.long_mem.purge_except(obj_keep_idx) + self.sensory = {k: v for k, v in self.sensory.items() if k in obj_keep_idx} + if not self.work_mem.engaged(): + self.engaged = False + + def compress_features(self, bucket_id: int) -> None: + k, sk, ek, value, usage = self.work_mem.get_all_sliced( + bucket_id, 0, -self.min_work_tokens + ) + prototype_key, prototype_value, prototype_shrinkage = self.consolidation( + k, sk, ek, value, usage + ) + self.work_mem.sieve_by_range( + bucket_id, 0, -self.min_work_tokens, min_size=self.min_work_tokens + ) + self.long_mem.add( + prototype_key, + prototype_value, + prototype_shrinkage, + selection=None, + supposed_bucket_id=bucket_id, + ) + + def consolidation( + self, + candidate_key: torch.Tensor, + candidate_shrinkage: torch.Tensor, + candidate_selection: torch.Tensor, + candidate_value: Dict[int, torch.Tensor], + usage: torch.Tensor, + ) -> tuple: + bs = candidate_key.shape[0] + prototype_key = [] + prototype_selection = [] + for bi in range(bs): + _, max_usage_indices = torch.topk( + usage[bi], k=self.num_prototypes, dim=-1, sorted=True + ) + prototype_indices = max_usage_indices.flatten() + prototype_key.append(candidate_key[bi, :, prototype_indices]) + if candidate_selection is not None: + prototype_selection.append( + candidate_selection[bi, :, prototype_indices] + ) + prototype_key = torch.stack(prototype_key, dim=0) + prototype_selection = ( + torch.stack(prototype_selection, dim=0) if prototype_selection else None + ) + similarity = get_similarity( + candidate_key, + candidate_shrinkage, + prototype_key, + prototype_selection, + ) + affinity = do_softmax(similarity) + prototype_value = { + k: self._readout(affinity, v) for k, v in candidate_value.items() + } + prototype_shrinkage = self._readout(affinity, candidate_shrinkage) + return prototype_key, prototype_value, prototype_shrinkage + + def initialize_sensory_if_needed( + self, sample_key: torch.Tensor, ids: List[int] + ) -> None: + for obj in ids: + if obj not in self.sensory: + bs, _, h, w = sample_key.shape + self.sensory[obj] = torch.zeros( + (bs, self.sensory_dim, h, w), + device=sample_key.device, + ) + + def update_sensory(self, sensory: torch.Tensor, ids: List[int]) -> None: + for obj_id, obj in enumerate(ids): + self.sensory[obj] = sensory[:, obj_id] + + def get_sensory(self, ids: List[int]): + return self._get_sensory_by_ids(ids) + + def clear_non_permanent_memory(self) -> None: + self.work_mem.clear_non_permanent_memory() + if self.use_long_term: + self.long_mem.clear_non_permanent_memory() + + def clear_sensory_memory(self) -> None: + self.sensory = {} + + def clear_work_mem(self) -> None: + self.work_mem = KeyValueMemoryStore( + save_selection=self.use_long_term, + save_usage=self.use_long_term, + ) + + def clear_obj_mem(self) -> None: + self.obj_v = {} diff --git a/src/matanyone2/inference/object_info.py b/src/matanyone2/inference/object_info.py new file mode 100644 index 0000000..7bebaf0 --- /dev/null +++ b/src/matanyone2/inference/object_info.py @@ -0,0 +1,28 @@ +""" +Object metadata for MatAnyone2 inference. +""" + + +class ObjectInfo: + """Stores meta information for an object.""" + + def __init__(self, id: int): + self.id = id + self.poke_count = 0 + + def poke(self) -> None: + self.poke_count += 1 + + def unpoke(self) -> None: + self.poke_count = 0 + + def __hash__(self): + return hash(self.id) + + def __eq__(self, other): + if type(other) == int: + return self.id == other + return self.id == other.id + + def __repr__(self): + return "(ID: %s)" % self.id diff --git a/src/matanyone2/inference/object_manager.py b/src/matanyone2/inference/object_manager.py new file mode 100644 index 0000000..05fbadf --- /dev/null +++ b/src/matanyone2/inference/object_manager.py @@ -0,0 +1,134 @@ +""" +Object manager for MatAnyone2 inference. +""" + +from typing import Dict, List, Union + +import torch + +from .object_info import ObjectInfo + + +class ObjectManager: + """ + Manages object IDs and temporary IDs. + Object IDs are immutable; temporary IDs indicate tensor positions. + """ + + def __init__(self): + self.obj_to_tmp_id: Dict[ObjectInfo, int] = {} + self.tmp_id_to_obj: Dict[int, ObjectInfo] = {} + self.obj_id_to_obj: Dict[int, ObjectInfo] = {} + self.all_historical_object_ids: List[int] = [] + + def _recompute_obj_id_to_obj_mapping(self) -> None: + self.obj_id_to_obj = {obj.id: obj for obj in self.obj_to_tmp_id} + + def add_new_objects( + self, + objects: Union[List[ObjectInfo], ObjectInfo, List[int]], + ) -> tuple: + if not isinstance(objects, list): + objects = [objects] + corresponding_tmp_ids = [] + corresponding_obj_ids = [] + for obj in objects: + if isinstance(obj, int): + obj = ObjectInfo(id=obj) + if obj in self.obj_to_tmp_id: + corresponding_tmp_ids.append(self.obj_to_tmp_id[obj]) + corresponding_obj_ids.append(obj.id) + else: + new_obj = ObjectInfo(id=obj.id) + new_tmp_id = len(self.obj_to_tmp_id) + 1 + self.obj_to_tmp_id[new_obj] = new_tmp_id + self.tmp_id_to_obj[new_tmp_id] = new_obj + self.all_historical_object_ids.append(new_obj.id) + corresponding_tmp_ids.append(new_tmp_id) + corresponding_obj_ids.append(obj.id) + self._recompute_obj_id_to_obj_mapping() + assert corresponding_tmp_ids == sorted(corresponding_tmp_ids) + return corresponding_tmp_ids, corresponding_obj_ids + + def delete_objects(self, obj_ids_to_remove: Union[int, List[int]]) -> None: + if isinstance(obj_ids_to_remove, int): + obj_ids_to_remove = [obj_ids_to_remove] + new_tmp_id = 1 + total_num_id = len(self.obj_to_tmp_id) + local_obj_to_tmp_id = {} + local_tmp_to_obj_id = {} + for tmp_iter in range(1, total_num_id + 1): + obj = self.tmp_id_to_obj[tmp_iter] + if obj.id not in obj_ids_to_remove: + local_obj_to_tmp_id[obj] = new_tmp_id + local_tmp_to_obj_id[new_tmp_id] = obj + new_tmp_id += 1 + self.obj_to_tmp_id = local_obj_to_tmp_id + self.tmp_id_to_obj = local_tmp_to_obj_id + self._recompute_obj_id_to_obj_mapping() + + def purge_inactive_objects(self, max_missed_detection_count: int) -> tuple: + obj_id_to_be_deleted = [] + tmp_id_to_be_deleted = [] + tmp_id_to_keep = [] + obj_id_to_keep = [] + for obj in self.obj_to_tmp_id: + if obj.poke_count > max_missed_detection_count: + obj_id_to_be_deleted.append(obj.id) + tmp_id_to_be_deleted.append(self.obj_to_tmp_id[obj]) + else: + tmp_id_to_keep.append(self.obj_to_tmp_id[obj]) + obj_id_to_keep.append(obj.id) + purge_activated = len(obj_id_to_be_deleted) > 0 + if purge_activated: + self.delete_objects(obj_id_to_be_deleted) + return purge_activated, tmp_id_to_keep, obj_id_to_keep + + def tmp_to_obj_cls(self, mask) -> torch.Tensor: + new_mask = torch.zeros_like(mask) + for tmp_id, obj in self.tmp_id_to_obj.items(): + new_mask[mask == tmp_id] = obj.id + return new_mask + + def get_tmp_to_obj_mapping(self) -> Dict[int, ObjectInfo]: + return {obj.id: tmp_id for obj, tmp_id in self.tmp_id_to_obj.items()} + + def realize_dict(self, obj_dict, dim=1) -> torch.Tensor: + output = [] + for _, obj in self.tmp_id_to_obj.items(): + if obj.id not in obj_dict: + raise NotImplementedError + output.append(obj_dict[obj.id]) + return torch.stack(output, dim=dim) + + def make_one_hot(self, cls_mask) -> torch.Tensor: + output = [] + for _, obj in self.tmp_id_to_obj.items(): + output.append(cls_mask == obj.id) + if len(output) == 0: + output = torch.zeros( + (0, *cls_mask.shape), dtype=torch.bool, device=cls_mask.device + ) + else: + output = torch.stack(output, dim=0) + return output + + @property + def all_obj_ids(self) -> List[int]: + return [k.id for k in self.obj_to_tmp_id] + + @property + def num_obj(self) -> int: + return len(self.obj_to_tmp_id) + + def has_all(self, objects: List[int]) -> bool: + for obj in objects: + if obj not in self.obj_id_to_obj: + return False + return True + + def find_object_by_id(self, obj_id) -> ObjectInfo: + return self.obj_id_to_obj[obj_id] + + def find_tmp_by_id(self, obj_id) -> int: + return self.obj_to_tmp_id[self.obj_id_to_obj[obj_id]] diff --git a/src/matanyone2/model/aux_modules.py b/src/matanyone2/model/aux_modules.py new file mode 100644 index 0000000..24184c2 --- /dev/null +++ b/src/matanyone2/model/aux_modules.py @@ -0,0 +1,98 @@ +""" +Auxiliary output modules for MatAnyone2. +""" + +from typing import Dict + +import torch +import torch.nn as nn +from omegaconf import DictConfig + +from ..utils.tensor_utils import aggregate +from .group_modules import GConv2d + + +class LinearPredictor(nn.Module): + """Linear predictor for auxiliary loss.""" + + def __init__(self, x_dim: int, pix_dim: int): + super().__init__() + self.projection = GConv2d(x_dim, pix_dim + 1, kernel_size=1) + + def forward(self, pix_feat: torch.Tensor, x: torch.Tensor) -> torch.Tensor: + num_objects = x.shape[1] + x = self.projection(x) + pix_feat = pix_feat.unsqueeze(1).expand(-1, num_objects, -1, -1, -1) + logits = (pix_feat * x[:, :, :-1]).sum(dim=2) + x[:, :, -1] + return logits + + +class DirectPredictor(nn.Module): + """Direct predictor for auxiliary loss.""" + + def __init__(self, x_dim: int): + super().__init__() + self.projection = GConv2d(x_dim, 1, kernel_size=1) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.projection(x).squeeze(2) + + +class AuxComputer(nn.Module): + """Computes auxiliary outputs for auxiliary losses.""" + + def __init__(self, cfg: DictConfig): + super().__init__() + use_sensory_aux = cfg.model.aux_loss.sensory.enabled + self.use_query_aux = cfg.model.aux_loss.query.enabled + self.use_sensory_aux = use_sensory_aux + sensory_dim = cfg.model.sensory_dim + embed_dim = cfg.model.embed_dim + + if use_sensory_aux: + self.sensory_aux = LinearPredictor(sensory_dim, embed_dim) + + def _aggregate_with_selector( + self, logits: torch.Tensor, selector: torch.Tensor + ) -> torch.Tensor: + prob = torch.sigmoid(logits) + if selector is not None: + prob = prob * selector + return aggregate(prob, dim=1) + + def forward( + self, + pix_feat: torch.Tensor, + aux_input: Dict[str, torch.Tensor], + selector: torch.Tensor, + seg_pass=False, + ) -> Dict[str, torch.Tensor]: + sensory = aux_input["sensory"] + q_logits = aux_input["q_logits"] + aux_output = {} + aux_output["attn_mask"] = aux_input["attn_mask"] + + if self.use_sensory_aux: + logits = self.sensory_aux(pix_feat, sensory) + aux_output["sensory_logits"] = self._aggregate_with_selector( + logits, selector + ) + if self.use_query_aux: + aux_output["q_logits"] = self._aggregate_with_selector( + torch.stack(q_logits, dim=2), + selector.unsqueeze(2) if selector is not None else None, + ) + return aux_output + + def compute_mask( + self, + aux_input: Dict[str, torch.Tensor], + selector: torch.Tensor, + ) -> Dict[str, torch.Tensor]: + q_logits = aux_input["q_logits"] + aux_output = {} + aux_output["q_logits"] = self._aggregate_with_selector( + torch.stack(q_logits, dim=2), + selector.unsqueeze(2) if selector is not None else None, + ) + return aux_output diff --git a/src/matanyone2/model/big_modules.py b/src/matanyone2/model/big_modules.py new file mode 100644 index 0000000..e1d82f1 --- /dev/null +++ b/src/matanyone2/model/big_modules.py @@ -0,0 +1,402 @@ +""" +High-level network blocks for MatAnyone2. +""" + +from typing import Iterable + +import torch +import torch.nn as nn +import torch.nn.functional as F +from omegaconf import DictConfig + +from ..utils.device import safe_autocast +from .group_modules import GConv2d, GroupFeatureFusionBlock, MainToGroupDistributor +from .modules import ( + DecoderFeatureProcessor, + MaskUpsampleBlock, + SensoryDeepUpdater, + SensoryUpdater_fullscale, +) +from .utils import resnet + + +class UncertPred(nn.Module): + """Uncertainty prediction module.""" + + def __init__(self, model_cfg: DictConfig): + super().__init__() + self.conv1x1_v2 = nn.Conv2d( + model_cfg.pixel_dim * 2 + 1 + model_cfg.value_dim, + 64, + kernel_size=1, + stride=1, + bias=False, + ) + self.bn1 = nn.BatchNorm2d(64) + self.relu = nn.ReLU(inplace=True) + self.conv3x3 = nn.Conv2d( + 64, 32, kernel_size=3, stride=1, padding=1, groups=1, bias=False, dilation=1 + ) + self.bn2 = nn.BatchNorm2d(32) + self.conv3x3_out = nn.Conv2d( + 32, 1, kernel_size=3, stride=1, padding=1, groups=1, bias=False, dilation=1 + ) + + def forward( + self, + last_frame_feat: torch.Tensor, + cur_frame_feat: torch.Tensor, + last_mask: torch.Tensor, + mem_val_diff: torch.Tensor, + ): + last_mask = F.interpolate( + last_mask, size=last_frame_feat.shape[-2:], mode="area" + ) + x = torch.cat([last_frame_feat, cur_frame_feat, last_mask, mem_val_diff], dim=1) + x = self.conv1x1_v2(x) + x = self.bn1(x) + x = self.relu(x) + x = self.conv3x3(x) + x = self.bn2(x) + x = self.relu(x) + x = self.conv3x3_out(x) + return x + + def train(self, mode=True): + self.training = False + for module in self.children(): + module.train(False) + return self + + +class PixelEncoder(nn.Module): + """Pixel/feature encoder (ResNet backbone).""" + + def __init__(self, model_cfg: DictConfig): + super().__init__() + self.is_resnet = "resnet" in model_cfg.pixel_encoder.type + is_pretrained_resnet = getattr(model_cfg, "pretrained_resnet", True) + if self.is_resnet: + if model_cfg.pixel_encoder.type == "resnet18": + network = resnet.resnet18(pretrained=is_pretrained_resnet) + elif model_cfg.pixel_encoder.type == "resnet50": + network = resnet.resnet50(pretrained=is_pretrained_resnet) + else: + raise NotImplementedError + self.conv1 = network.conv1 + self.bn1 = network.bn1 + self.relu = network.relu + self.maxpool = network.maxpool + self.res2 = network.layer1 + self.layer2 = network.layer2 + self.layer3 = network.layer3 + else: + raise NotImplementedError + + def forward(self, x: torch.Tensor, seq_length=None) -> tuple: + f1 = x + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + f2 = x + x = self.maxpool(x) + f4 = self.res2(x) + f8 = self.layer2(f4) + f16 = self.layer3(f8) + return f16, f8, f4, f2, f1 + + def train(self, mode=True): + self.training = False + for module in self.children(): + module.train(False) + return self + + +class KeyProjection(nn.Module): + """Key projection for memory.""" + + def __init__(self, model_cfg: DictConfig): + super().__init__() + in_dim = model_cfg.pixel_encoder.ms_dims[0] + mid_dim = model_cfg.pixel_dim + key_dim = model_cfg.key_dim + self.pix_feat_proj = nn.Conv2d(in_dim, mid_dim, kernel_size=1) + self.key_proj = nn.Conv2d(mid_dim, key_dim, kernel_size=3, padding=1) + self.d_proj = nn.Conv2d(mid_dim, 1, kernel_size=3, padding=1) + self.e_proj = nn.Conv2d(mid_dim, key_dim, kernel_size=3, padding=1) + nn.init.orthogonal_(self.key_proj.weight.data) + nn.init.zeros_(self.key_proj.bias.data) + + def forward(self, x: torch.Tensor, *, need_s: bool, need_e: bool) -> tuple: + x = self.pix_feat_proj(x) + shrinkage = self.d_proj(x) ** 2 + 1 if need_s else None + selection = torch.sigmoid(self.e_proj(x)) if need_e else None + return self.key_proj(x), shrinkage, selection + + +class MaskEncoder(nn.Module): + """Mask encoder with ResNet backbone.""" + + def __init__(self, model_cfg: DictConfig, single_object=False): + super().__init__() + pixel_dim = model_cfg.pixel_dim + value_dim = model_cfg.value_dim + sensory_dim = model_cfg.sensory_dim + final_dim = model_cfg.mask_encoder.final_dim + self.single_object = single_object + extra_dim = 1 if single_object else 2 + + is_pretrained_resnet = getattr(model_cfg, "pretrained_resnet", True) + if model_cfg.mask_encoder.type == "resnet18": + network = resnet.resnet18( + pretrained=is_pretrained_resnet, extra_dim=extra_dim + ) + elif model_cfg.mask_encoder.type == "resnet50": + network = resnet.resnet50( + pretrained=is_pretrained_resnet, extra_dim=extra_dim + ) + else: + raise NotImplementedError + + self.conv1 = network.conv1 + self.bn1 = network.bn1 + self.relu = network.relu + self.maxpool = network.maxpool + self.layer1 = network.layer1 + self.layer2 = network.layer2 + self.layer3 = network.layer3 + self.distributor = MainToGroupDistributor() + self.fuser = GroupFeatureFusionBlock(pixel_dim, final_dim, value_dim) + self.sensory_update = SensoryDeepUpdater(value_dim, sensory_dim) + + def forward( + self, + image: torch.Tensor, + pix_feat: torch.Tensor, + sensory: torch.Tensor, + masks: torch.Tensor, + others: torch.Tensor, + *, + deep_update: bool = True, + chunk_size: int = -1, + ) -> tuple: + if self.single_object: + g = masks.unsqueeze(2) + else: + g = torch.stack([masks, others], dim=2) + + g = self.distributor(image, g) + batch_size, num_objects = g.shape[:2] + + if chunk_size < 1 or chunk_size >= num_objects: + chunk_size = num_objects + fast_path = True + new_sensory = sensory + else: + new_sensory = torch.empty_like(sensory) if deep_update else sensory + fast_path = False + + all_g = [] + for i in range(0, num_objects, chunk_size): + g_chunk = g if fast_path else g[:, i : i + chunk_size] + actual_chunk_size = g_chunk.shape[1] + g_chunk = g_chunk.flatten(start_dim=0, end_dim=1) + + g_chunk = self.conv1(g_chunk) + g_chunk = self.bn1(g_chunk) + g_chunk = self.maxpool(g_chunk) + g_chunk = self.relu(g_chunk) + g_chunk = self.layer1(g_chunk) + g_chunk = self.layer2(g_chunk) + g_chunk = self.layer3(g_chunk) + + g_chunk = g_chunk.view(batch_size, actual_chunk_size, *g_chunk.shape[1:]) + g_chunk = self.fuser(pix_feat, g_chunk) + all_g.append(g_chunk) + + if deep_update: + if fast_path: + new_sensory = self.sensory_update(g_chunk, sensory) + else: + new_sensory[:, i : i + chunk_size] = self.sensory_update( + g_chunk, sensory[:, i : i + chunk_size] + ) + + g = torch.cat(all_g, dim=1) + return g, new_sensory + + def train(self, mode=True): + self.training = False + for module in self.children(): + module.train(False) + return self + + +class PixelFeatureFuser(nn.Module): + """Fuses pixel and sensory memory features.""" + + def __init__(self, model_cfg: DictConfig, single_object=False): + super().__init__() + value_dim = model_cfg.value_dim + sensory_dim = model_cfg.sensory_dim + pixel_dim = model_cfg.pixel_dim + embed_dim = model_cfg.embed_dim + self.single_object = single_object + self.fuser = GroupFeatureFusionBlock(pixel_dim, value_dim, embed_dim) + if self.single_object: + self.sensory_compress = GConv2d(sensory_dim + 1, value_dim, kernel_size=1) + else: + self.sensory_compress = GConv2d(sensory_dim + 2, value_dim, kernel_size=1) + + def forward( + self, + pix_feat: torch.Tensor, + pixel_memory: torch.Tensor, + sensory_memory: torch.Tensor, + last_mask: torch.Tensor, + last_others: torch.Tensor, + *, + chunk_size: int = -1, + ) -> torch.Tensor: + batch_size, num_objects = pixel_memory.shape[:2] + if self.single_object: + last_mask = last_mask.unsqueeze(2) + else: + last_mask = torch.stack([last_mask, last_others], dim=2) + + if chunk_size < 1: + chunk_size = num_objects + + all_p16 = [] + for i in range(0, num_objects, chunk_size): + sensory_readout = self.sensory_compress( + torch.cat( + [ + sensory_memory[:, i : i + chunk_size], + last_mask[:, i : i + chunk_size], + ], + 2, + ) + ) + p16 = pixel_memory[:, i : i + chunk_size] + sensory_readout + p16 = self.fuser(pix_feat, p16) + all_p16.append(p16) + p16 = torch.cat(all_p16, dim=1) + return p16 + + +class MaskDecoder(nn.Module): + """Mask decoder with multi-scale upsample.""" + + def __init__(self, model_cfg: DictConfig): + super().__init__() + embed_dim = model_cfg.embed_dim + sensory_dim = model_cfg.sensory_dim + ms_image_dims = model_cfg.pixel_encoder.ms_dims + up_dims = model_cfg.mask_decoder.up_dims + + assert embed_dim == up_dims[0] + + self.sensory_update = SensoryUpdater_fullscale( + [ + up_dims[0], + up_dims[1], + up_dims[2], + up_dims[3], + up_dims[4] + 1, + ], + sensory_dim, + sensory_dim, + ) + self.decoder_feat_proc = DecoderFeatureProcessor( + ms_image_dims[1:], up_dims[:-1] + ) + self.up_16_8 = MaskUpsampleBlock(up_dims[0], up_dims[1]) + self.up_8_4 = MaskUpsampleBlock(up_dims[1], up_dims[2]) + self.up_4_2 = MaskUpsampleBlock(up_dims[2], up_dims[3]) + self.up_2_1 = MaskUpsampleBlock(up_dims[3], up_dims[4]) + self.pred_seg = nn.Conv2d(up_dims[-1], 1, kernel_size=3, padding=1) + self.pred_mat = nn.Conv2d(up_dims[-1], 1, kernel_size=3, padding=1) + + def forward( + self, + ms_image_feat: Iterable[torch.Tensor], + memory_readout: torch.Tensor, + sensory: torch.Tensor, + *, + chunk_size: int = -1, + update_sensory: bool = True, + seg_pass: bool = False, + last_mask=None, + sigmoid_residual=False, + ) -> tuple: + batch_size, num_objects = memory_readout.shape[:2] + f8, f4, f2, f1 = self.decoder_feat_proc(ms_image_feat[1:]) + + if chunk_size < 1 or chunk_size >= num_objects: + chunk_size = num_objects + fast_path = True + new_sensory = sensory + else: + new_sensory = torch.empty_like(sensory) if update_sensory else sensory + fast_path = False + + all_logits = [] + for i in range(0, num_objects, chunk_size): + p16 = memory_readout if fast_path else memory_readout[:, i : i + chunk_size] + actual_chunk_size = p16.shape[1] + + p8 = self.up_16_8(p16, f8) + p4 = self.up_8_4(p8, f4) + p2 = self.up_4_2(p4, f2) + p1 = self.up_2_1(p2, f1) + + with safe_autocast(enabled=False): + if seg_pass: + if last_mask is not None: + res = self.pred_seg( + F.relu(p1.flatten(start_dim=0, end_dim=1).float()) + ) + if sigmoid_residual: + res = (torch.sigmoid(res) - 0.5) * 2 + logits = last_mask + res + else: + logits = self.pred_seg( + F.relu(p1.flatten(start_dim=0, end_dim=1).float()) + ) + else: + if last_mask is not None: + res = self.pred_mat( + F.relu(p1.flatten(start_dim=0, end_dim=1).float()) + ) + if sigmoid_residual: + res = (torch.sigmoid(res) - 0.5) * 2 + logits = last_mask + res + else: + logits = self.pred_mat( + F.relu(p1.flatten(start_dim=0, end_dim=1).float()) + ) + + if update_sensory: + p1 = torch.cat( + [ + p1, + logits.view( + batch_size, actual_chunk_size, 1, *logits.shape[-2:] + ), + ], + 2, + ) + if fast_path: + new_sensory = self.sensory_update([p16, p8, p4, p2, p1], sensory) + else: + new_sensory[:, i : i + chunk_size] = self.sensory_update( + [p16, p8, p4, p2, p1], + sensory[:, i : i + chunk_size], + ) + + all_logits.append(logits) + + logits = torch.cat(all_logits, dim=0) + logits = logits.view(batch_size, num_objects, *logits.shape[-2:]) + return new_sensory, logits diff --git a/src/matanyone2/model/channel_attn.py b/src/matanyone2/model/channel_attn.py new file mode 100644 index 0000000..f28febb --- /dev/null +++ b/src/matanyone2/model/channel_attn.py @@ -0,0 +1,46 @@ +""" +Channel attention block for MatAnyone2. +""" + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class CAResBlock(nn.Module): + """Channel attention residual block.""" + + def __init__(self, in_dim: int, out_dim: int, residual: bool = True): + super().__init__() + self.residual = residual + self.conv1 = nn.Conv2d(in_dim, out_dim, kernel_size=3, padding=1) + self.conv2 = nn.Conv2d(out_dim, out_dim, kernel_size=3, padding=1) + + t = int((abs(math.log2(out_dim)) + 1) // 2) + k = t if t % 2 else t + 1 + self.pool = nn.AdaptiveAvgPool2d(1) + self.conv = nn.Conv1d(1, 1, kernel_size=k, padding=(k - 1) // 2, bias=False) + + if self.residual: + if in_dim == out_dim: + self.downsample = nn.Identity() + else: + self.downsample = nn.Conv2d(in_dim, out_dim, kernel_size=1) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + r = x + x = self.conv1(F.relu(x)) + x = self.conv2(F.relu(x)) + + b, c = x.shape[:2] + w = self.pool(x).view(b, 1, c) + w = self.conv(w).transpose(-1, -2).unsqueeze(-1).sigmoid() + + if self.residual: + x = x * w + self.downsample(r) + else: + x = x * w + + return x diff --git a/src/matanyone2/model/group_modules.py b/src/matanyone2/model/group_modules.py new file mode 100644 index 0000000..240405f --- /dev/null +++ b/src/matanyone2/model/group_modules.py @@ -0,0 +1,139 @@ +""" +Group convolution and feature fusion modules for MatAnyone2. +""" + +from typing import Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .channel_attn import CAResBlock + + +def interpolate_groups( + g: torch.Tensor, ratio: float, mode: str, align_corners: bool +) -> torch.Tensor: + """Interpolates group tensor by ratio.""" + batch_size, num_objects = g.shape[:2] + g = F.interpolate( + g.flatten(start_dim=0, end_dim=1), + scale_factor=ratio, + mode=mode, + align_corners=align_corners, + ) + g = g.view(batch_size, num_objects, *g.shape[1:]) + return g + + +def upsample_groups( + g: torch.Tensor, + ratio: float = 2, + mode: str = "bilinear", + align_corners: bool = False, +) -> torch.Tensor: + """Upsamples group tensor.""" + return interpolate_groups(g, ratio, mode, align_corners) + + +def downsample_groups( + g: torch.Tensor, + ratio: float = 1 / 2, + mode: str = "area", + align_corners: bool = None, +) -> torch.Tensor: + """Downsamples group tensor.""" + return interpolate_groups(g, ratio, mode, align_corners) + + +class GConv2d(nn.Conv2d): + """Group convolution (batch, num_objects, C, H, W).""" + + def forward(self, g: torch.Tensor) -> torch.Tensor: + batch_size, num_objects = g.shape[:2] + g = super().forward(g.flatten(start_dim=0, end_dim=1)) + return g.view(batch_size, num_objects, *g.shape[1:]) + + +class GroupResBlock(nn.Module): + """Residual block for group tensors.""" + + def __init__(self, in_dim: int, out_dim: int): + super().__init__() + if in_dim == out_dim: + self.downsample = nn.Identity() + else: + self.downsample = GConv2d(in_dim, out_dim, kernel_size=1) + self.conv1 = GConv2d(in_dim, out_dim, kernel_size=3, padding=1) + self.conv2 = GConv2d(out_dim, out_dim, kernel_size=3, padding=1) + + def forward(self, g: torch.Tensor) -> torch.Tensor: + out_g = self.conv1(F.relu(g)) + out_g = self.conv2(F.relu(out_g)) + g = self.downsample(g) + return out_g + g + + +class MainToGroupDistributor(nn.Module): + """Distributes main features to group dimension.""" + + def __init__( + self, + x_transform: Optional[nn.Module] = None, + g_transform: Optional[nn.Module] = None, + method: str = "cat", + reverse_order: bool = False, + ): + super().__init__() + self.x_transform = x_transform + self.g_transform = g_transform + self.method = method + self.reverse_order = reverse_order + + def forward( + self, x: torch.Tensor, g: torch.Tensor, skip_expand: bool = False + ) -> torch.Tensor: + num_objects = g.shape[1] + if self.x_transform is not None: + x = self.x_transform(x) + if self.g_transform is not None: + g = self.g_transform(g) + if not skip_expand: + x = x.unsqueeze(1).expand(-1, num_objects, -1, -1, -1) + if self.method == "cat": + if self.reverse_order: + g = torch.cat([g, x], 2) + else: + g = torch.cat([x, g], 2) + elif self.method == "add": + g = x + g + elif self.method == "mulcat": + g = torch.cat([x * g, g], dim=2) + elif self.method == "muladd": + g = x * g + g + else: + raise NotImplementedError + return g + + +class GroupFeatureFusionBlock(nn.Module): + """Fuses main and group features.""" + + def __init__(self, x_in_dim: int, g_in_dim: int, out_dim: int): + super().__init__() + x_transform = nn.Conv2d(x_in_dim, out_dim, kernel_size=1) + g_transform = GConv2d(g_in_dim, out_dim, kernel_size=1) + self.distributor = MainToGroupDistributor( + x_transform=x_transform, g_transform=g_transform, method="add" + ) + self.block1 = CAResBlock(out_dim, out_dim) + self.block2 = CAResBlock(out_dim, out_dim) + + def forward(self, x: torch.Tensor, g: torch.Tensor) -> torch.Tensor: + batch_size, num_objects = g.shape[:2] + g = self.distributor(x, g) + g = g.flatten(start_dim=0, end_dim=1) + g = self.block1(g) + g = self.block2(g) + g = g.view(batch_size, num_objects, *g.shape[1:]) + return g diff --git a/src/matanyone2/model/matanyone2.py b/src/matanyone2/model/matanyone2.py new file mode 100644 index 0000000..c72ee30 --- /dev/null +++ b/src/matanyone2/model/matanyone2.py @@ -0,0 +1,364 @@ +""" +MatAnyone2 model - video matting network. +""" + +import logging +from typing import Dict, Iterable, List, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from omegaconf import DictConfig, OmegaConf + +from ..utils.device import get_default_device, safe_autocast +from ..utils.tensor_utils import aggregate +from .aux_modules import AuxComputer +from .big_modules import ( + KeyProjection, + MaskDecoder, + MaskEncoder, + PixelEncoder, + PixelFeatureFuser, + UncertPred, +) +from .transformer.object_summarizer import ObjectSummarizer +from .transformer.object_transformer import QueryTransformer +from .utils.memory_utils import get_affinity, readout + +log = logging.getLogger() + + +class MatAnyone2(nn.Module): + """MatAnyone2 video matting model.""" + + def __init__(self, cfg: DictConfig, *, single_object=False): + super().__init__() + self.cfg = cfg + model_cfg = cfg.model + self.ms_dims = model_cfg.pixel_encoder.ms_dims + self.key_dim = model_cfg.key_dim + self.value_dim = model_cfg.value_dim + self.sensory_dim = model_cfg.sensory_dim + self.pixel_dim = model_cfg.pixel_dim + self.embed_dim = model_cfg.embed_dim + self.single_object = single_object + + log.info("Single object: %s", self.single_object) + + self.pixel_encoder = PixelEncoder(model_cfg) + self.pix_feat_proj = nn.Conv2d(self.ms_dims[0], self.pixel_dim, kernel_size=1) + self.key_proj = KeyProjection(model_cfg) + self.mask_encoder = MaskEncoder(model_cfg, single_object=single_object) + self.mask_decoder = MaskDecoder(model_cfg) + self.pixel_fuser = PixelFeatureFuser(model_cfg, single_object=single_object) + self.object_transformer = QueryTransformer(model_cfg) + self.object_summarizer = ObjectSummarizer(model_cfg) + self.aux_computer = AuxComputer(cfg) + self.temp_sparity = UncertPred(model_cfg) + + self.register_buffer( + "pixel_mean", + torch.Tensor(model_cfg.pixel_mean).view(-1, 1, 1), + False, + ) + self.register_buffer( + "pixel_std", + torch.Tensor(model_cfg.pixel_std).view(-1, 1, 1), + False, + ) + + def _get_others(self, masks: torch.Tensor) -> torch.Tensor: + if self.single_object: + return None + num_objects = masks.shape[1] + if num_objects >= 1: + others = (masks.sum(dim=1, keepdim=True) - masks).clamp(0, 1) + else: + others = torch.zeros_like(masks) + return others + + def pred_uncertainty( + self, + last_pix_feat: torch.Tensor, + cur_pix_feat: torch.Tensor, + last_mask: torch.Tensor, + mem_val_diff: torch.Tensor, + ): + logits = self.temp_sparity( + last_frame_feat=last_pix_feat, + cur_frame_feat=cur_pix_feat, + last_mask=last_mask, + mem_val_diff=mem_val_diff, + ) + prob = torch.sigmoid(logits) + mask = (prob > 0) + 0 + return {"logits": logits, "prob": prob, "mask": mask} + + def encode_image( + self, image: torch.Tensor, seq_length=None, last_feats=None + ) -> tuple: + device = get_default_device() + self.pixel_mean = self.pixel_mean.to(device) + self.pixel_std = self.pixel_std.to(device) + image = (image - self.pixel_mean) / self.pixel_std + ms_image_feat = self.pixel_encoder(image, seq_length) + return ms_image_feat, self.pix_feat_proj(ms_image_feat[0]) + + def encode_mask( + self, + image: torch.Tensor, + ms_features: List[torch.Tensor], + sensory: torch.Tensor, + masks: torch.Tensor, + *, + deep_update: bool = True, + chunk_size: int = -1, + need_weights: bool = False, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + image = (image - self.pixel_mean) / self.pixel_std + others = self._get_others(masks) + mask_value, new_sensory = self.mask_encoder( + image, + ms_features, + sensory, + masks, + others, + deep_update=deep_update, + chunk_size=chunk_size, + ) + object_summaries, object_logits = self.object_summarizer( + masks, mask_value, need_weights + ) + return mask_value, new_sensory, object_summaries, object_logits + + def transform_key( + self, + final_pix_feat: torch.Tensor, + *, + need_sk: bool = True, + need_ek: bool = True, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + key, shrinkage, selection = self.key_proj( + final_pix_feat, need_s=need_sk, need_e=need_ek + ) + return key, shrinkage, selection + + def read_memory( + self, + query_key: torch.Tensor, + query_selection: torch.Tensor, + memory_key: torch.Tensor, + memory_shrinkage: torch.Tensor, + msk_value: torch.Tensor, + obj_memory: torch.Tensor, + pix_feat: torch.Tensor, + sensory: torch.Tensor, + last_mask: torch.Tensor, + selector: torch.Tensor, + uncert_output=None, + seg_pass=False, + last_pix_feat=None, + last_pred_mask=None, + ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor], dict]: + batch_size, num_objects = msk_value.shape[:2] + uncert_mask = uncert_output["mask"] if uncert_output is not None else None + + with safe_autocast(enabled=False): + affinity = get_affinity( + memory_key.float(), + memory_shrinkage.float(), + query_key.float(), + query_selection.float(), + uncert_mask=uncert_mask, + ) + msk_value_flat = msk_value.flatten(start_dim=1, end_dim=2).float() + pixel_readout = readout(affinity, msk_value_flat, uncert_mask) + pixel_readout = pixel_readout.view( + batch_size, num_objects, self.value_dim, *pixel_readout.shape[-2:] + ) + + last_val = msk_value[:, :, :, -1] + mem_val_diff = pixel_readout[:, 0] - last_val[:, 0] + uncert_output = self.pred_uncertainty( + last_pix_feat, pix_feat, last_pred_mask, mem_val_diff + ) + uncert_prob = uncert_output["prob"].unsqueeze(1) + pixel_readout = pixel_readout * uncert_prob + last_val.unsqueeze(2) * ( + 1 - uncert_prob + ) + + pixel_readout = self.pixel_fusion(pix_feat, pixel_readout, sensory, last_mask) + mem_readout, aux_features = self.readout_query( + pixel_readout, obj_memory, selector=selector, seg_pass=seg_pass + ) + aux_output = { + "sensory": sensory, + "q_logits": aux_features["logits"] if aux_features else None, + "attn_mask": aux_features["attn_mask"] if aux_features else None, + } + return mem_readout, aux_output, uncert_output + + def read_first_frame_memory( + self, + pixel_readout: torch.Tensor, + obj_memory: torch.Tensor, + pix_feat: torch.Tensor, + sensory: torch.Tensor, + last_mask: torch.Tensor, + selector: torch.Tensor, + seg_pass=False, + ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]: + pixel_readout = self.pixel_fusion(pix_feat, pixel_readout, sensory, last_mask) + mem_readout, aux_features = self.readout_query( + pixel_readout, obj_memory, selector=selector, seg_pass=seg_pass + ) + aux_output = { + "sensory": sensory, + "q_logits": aux_features["logits"] if aux_features else None, + "attn_mask": aux_features["attn_mask"] if aux_features else None, + } + return mem_readout, aux_output + + def pixel_fusion( + self, + pix_feat: torch.Tensor, + pixel: torch.Tensor, + sensory: torch.Tensor, + last_mask: torch.Tensor, + *, + chunk_size: int = -1, + ) -> torch.Tensor: + last_mask = F.interpolate(last_mask, size=sensory.shape[-2:], mode="area") + last_others = self._get_others(last_mask) + return self.pixel_fuser( + pix_feat, + pixel, + sensory, + last_mask, + last_others, + chunk_size=chunk_size, + ) + + def readout_query( + self, + pixel_readout: torch.Tensor, + obj_memory: torch.Tensor, + *, + selector=None, + need_weights=False, + seg_pass=False, + ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]: + return self.object_transformer( + pixel_readout, + obj_memory, + selector=selector, + need_weights=need_weights, + seg_pass=seg_pass, + ) + + def segment( + self, + ms_image_feat: List[torch.Tensor], + memory_readout: torch.Tensor, + sensory: torch.Tensor, + *, + selector=None, + chunk_size: int = -1, + update_sensory: bool = True, + seg_pass: bool = False, + clamp_mat: bool = True, + last_mask=None, + sigmoid_residual=False, + seg_mat=False, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + if seg_mat: + assert seg_pass + seg_pass = False + + sensory, logits = self.mask_decoder( + ms_image_feat, + memory_readout, + sensory, + chunk_size=chunk_size, + update_sensory=update_sensory, + seg_pass=seg_pass, + last_mask=last_mask, + sigmoid_residual=sigmoid_residual, + ) + if seg_pass: + prob = torch.sigmoid(logits) + if selector is not None: + prob = prob * selector + logits = aggregate(prob, dim=1) + prob = F.softmax(logits, dim=1) + else: + if clamp_mat: + logits = logits.clamp(0.0, 1.0) + logits = torch.cat([torch.prod(1 - logits, dim=1, keepdim=True), logits], 1) + prob = logits + + return sensory, logits, prob + + def compute_aux( + self, + pix_feat: torch.Tensor, + aux_inputs: Dict[str, torch.Tensor], + selector: torch.Tensor, + seg_pass=False, + ) -> Dict[str, torch.Tensor]: + return self.aux_computer(pix_feat, aux_inputs, selector, seg_pass=seg_pass) + + def forward(self, *args, **kwargs): + raise NotImplementedError + + def load_weights(self, src_dict, init_as_zero_if_needed=False) -> None: + if not self.single_object: + for k in list(src_dict.keys()): + if k == "mask_encoder.conv1.weight": + if src_dict[k].shape[1] == 4: + log.info( + "Converting %s from single object to multiple objects.", + k, + ) + pads = torch.zeros((64, 1, 7, 7), device=src_dict[k].device) + if not init_as_zero_if_needed: + nn.init.orthogonal_(pads) + src_dict[k] = torch.cat([src_dict[k], pads], 1) + elif k == "pixel_fuser.sensory_compress.weight": + if src_dict[k].shape[1] == self.sensory_dim + 1: + log.info( + "Converting %s from single object to multiple objects.", + k, + ) + pads = torch.zeros( + (self.value_dim, 1, 1, 1), + device=src_dict[k].device, + ) + if not init_as_zero_if_needed: + nn.init.orthogonal_(pads) + src_dict[k] = torch.cat([src_dict[k], pads], 1) + elif self.single_object: + if src_dict["mask_encoder.conv1.weight"].shape[1] == 5: + log.warning( + "Converting mask_encoder.conv1.weight from multiple " + "objects to single object." + ) + src_dict["mask_encoder.conv1.weight"] = src_dict[ + "mask_encoder.conv1.weight" + ][:, :-1] + src_dict["pixel_fuser.sensory_compress.weight"] = src_dict[ + "pixel_fuser.sensory_compress.weight" + ][:, :-1] + + for k in src_dict: + if k not in self.state_dict(): + log.info("Key %s found in src_dict but not in self.state_dict()", k) + for k in self.state_dict(): + if k not in src_dict: + log.info("Key %s found in self.state_dict() but not in src_dict", k) + + self.load_state_dict(src_dict, strict=False) + + @property + def device(self) -> torch.device: + return self.pixel_mean.device diff --git a/src/matanyone2/model/modules.py b/src/matanyone2/model/modules.py new file mode 100644 index 0000000..6754841 --- /dev/null +++ b/src/matanyone2/model/modules.py @@ -0,0 +1,173 @@ +""" +Decoder and sensory updater modules for MatAnyone2. +""" + +from typing import Iterable, List + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from ..utils.device import safe_autocast +from .group_modules import ( + GConv2d, + GroupResBlock, + MainToGroupDistributor, + downsample_groups, + upsample_groups, +) + + +class UpsampleBlock(nn.Module): + """Upsample block with residual connection.""" + + def __init__(self, in_dim: int, out_dim: int, scale_factor: int = 2): + super().__init__() + self.out_conv = ResBlock(in_dim, out_dim) + self.scale_factor = scale_factor + + def forward(self, in_g: torch.Tensor, skip_f: torch.Tensor) -> torch.Tensor: + g = F.interpolate(in_g, scale_factor=self.scale_factor, mode="bilinear") + g = self.out_conv(g) + g = g + skip_f + return g + + +class MaskUpsampleBlock(nn.Module): + """Mask upsample block with group features.""" + + def __init__(self, in_dim: int, out_dim: int, scale_factor: int = 2): + super().__init__() + self.distributor = MainToGroupDistributor(method="add") + self.out_conv = GroupResBlock(in_dim, out_dim) + self.scale_factor = scale_factor + + def forward(self, in_g: torch.Tensor, skip_f: torch.Tensor) -> torch.Tensor: + g = upsample_groups(in_g, ratio=self.scale_factor) + g = self.distributor(skip_f, g) + g = self.out_conv(g) + return g + + +class DecoderFeatureProcessor(nn.Module): + """Processes multi-scale decoder features.""" + + def __init__(self, decoder_dims: List[int], out_dims: List[int]): + super().__init__() + self.transforms = nn.ModuleList( + [ + nn.Conv2d(d_dim, p_dim, kernel_size=1) + for d_dim, p_dim in zip(decoder_dims, out_dims) + ] + ) + + def forward( + self, multi_scale_features: Iterable[torch.Tensor] + ) -> List[torch.Tensor]: + return [func(x) for x, func in zip(multi_scale_features, self.transforms)] + + +def _recurrent_update(h: torch.Tensor, values: torch.Tensor) -> torch.Tensor: + """GRU-like recurrent update.""" + dim = values.shape[2] // 3 + forget_gate = torch.sigmoid(values[:, :, :dim]) + update_gate = torch.sigmoid(values[:, :, dim : dim * 2]) + new_value = torch.tanh(values[:, :, dim * 2 :]) + new_h = forget_gate * h * (1 - update_gate) + update_gate * new_value + return new_h + + +class SensoryUpdater_fullscale(nn.Module): + """Full-scale sensory updater for decoder.""" + + def __init__(self, g_dims: List[int], mid_dim: int, sensory_dim: int): + super().__init__() + self.g16_conv = GConv2d(g_dims[0], mid_dim, kernel_size=1) + self.g8_conv = GConv2d(g_dims[1], mid_dim, kernel_size=1) + self.g4_conv = GConv2d(g_dims[2], mid_dim, kernel_size=1) + self.g2_conv = GConv2d(g_dims[3], mid_dim, kernel_size=1) + self.g1_conv = GConv2d(g_dims[4], mid_dim, kernel_size=1) + self.transform = GConv2d( + mid_dim + sensory_dim, sensory_dim * 3, kernel_size=3, padding=1 + ) + nn.init.xavier_normal_(self.transform.weight) + + def forward(self, g: torch.Tensor, h: torch.Tensor) -> torch.Tensor: + g = ( + self.g16_conv(g[0]) + + self.g8_conv(downsample_groups(g[1], ratio=1 / 2)) + + self.g4_conv(downsample_groups(g[2], ratio=1 / 4)) + + self.g2_conv(downsample_groups(g[3], ratio=1 / 8)) + + self.g1_conv(downsample_groups(g[4], ratio=1 / 16)) + ) + with safe_autocast(enabled=False): + g = g.float() + h = h.float() + values = self.transform(torch.cat([g, h], dim=2)) + new_h = _recurrent_update(h, values) + return new_h + + +class SensoryUpdater(nn.Module): + """Sensory updater for decoder (reduced scale).""" + + def __init__(self, g_dims: List[int], mid_dim: int, sensory_dim: int): + super().__init__() + self.g16_conv = GConv2d(g_dims[0], mid_dim, kernel_size=1) + self.g8_conv = GConv2d(g_dims[1], mid_dim, kernel_size=1) + self.g4_conv = GConv2d(g_dims[2], mid_dim, kernel_size=1) + self.transform = GConv2d( + mid_dim + sensory_dim, sensory_dim * 3, kernel_size=3, padding=1 + ) + nn.init.xavier_normal_(self.transform.weight) + + def forward(self, g: torch.Tensor, h: torch.Tensor) -> torch.Tensor: + g = ( + self.g16_conv(g[0]) + + self.g8_conv(downsample_groups(g[1], ratio=1 / 2)) + + self.g4_conv(downsample_groups(g[2], ratio=1 / 4)) + ) + with safe_autocast(enabled=False): + g = g.float() + h = h.float() + values = self.transform(torch.cat([g, h], dim=2)) + new_h = _recurrent_update(h, values) + return new_h + + +class SensoryDeepUpdater(nn.Module): + """Deep sensory updater.""" + + def __init__(self, f_dim: int, sensory_dim: int): + super().__init__() + self.transform = GConv2d( + f_dim + sensory_dim, sensory_dim * 3, kernel_size=3, padding=1 + ) + nn.init.xavier_normal_(self.transform.weight) + + def forward(self, g: torch.Tensor, h: torch.Tensor) -> torch.Tensor: + with safe_autocast(enabled=False): + g = g.float() + h = h.float() + values = self.transform(torch.cat([g, h], dim=2)) + new_h = _recurrent_update(h, values) + return new_h + + +class ResBlock(nn.Module): + """Residual block.""" + + def __init__(self, in_dim: int, out_dim: int): + super().__init__() + if in_dim == out_dim: + self.downsample = nn.Identity() + else: + self.downsample = nn.Conv2d(in_dim, out_dim, kernel_size=1) + self.conv1 = nn.Conv2d(in_dim, out_dim, kernel_size=3, padding=1) + self.conv2 = nn.Conv2d(out_dim, out_dim, kernel_size=3, padding=1) + + def forward(self, g: torch.Tensor) -> torch.Tensor: + out_g = self.conv1(F.relu(g)) + out_g = self.conv2(F.relu(out_g)) + g = self.downsample(g) + return out_g + g diff --git a/src/matanyone2/model/transformer/__init__.py b/src/matanyone2/model/transformer/__init__.py new file mode 100644 index 0000000..422cf38 --- /dev/null +++ b/src/matanyone2/model/transformer/__init__.py @@ -0,0 +1 @@ +"""MatAnyone2 transformer modules.""" diff --git a/src/matanyone2/model/transformer/object_summarizer.py b/src/matanyone2/model/transformer/object_summarizer.py new file mode 100644 index 0000000..387ed6f --- /dev/null +++ b/src/matanyone2/model/transformer/object_summarizer.py @@ -0,0 +1,92 @@ +""" +Object summarizer for MatAnyone2. +""" + +from typing import Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F +from omegaconf import DictConfig + +from ...utils.device import safe_autocast +from .positional_encoding import PositionalEncoding + + +def _weighted_pooling( + masks: torch.Tensor, value: torch.Tensor, logits: torch.Tensor +) -> tuple: + """Weighted pooling of value by logits and masks.""" + weights = logits.sigmoid() * masks + sums = torch.einsum("bkhwq,bkhwc->bkqc", weights, value) + area = weights.flatten(start_dim=2, end_dim=3).sum(2).unsqueeze(-1) + return sums, area + + +class ObjectSummarizer(nn.Module): + """Summarizes object features into fixed-size representations.""" + + def __init__(self, model_cfg: DictConfig): + super().__init__() + this_cfg = model_cfg.object_summarizer + self.value_dim = model_cfg.value_dim + self.embed_dim = this_cfg.embed_dim + self.num_summaries = this_cfg.num_summaries + self.add_pe = this_cfg.add_pe + self.pixel_pe_scale = model_cfg.pixel_pe_scale + self.pixel_pe_temperature = model_cfg.pixel_pe_temperature + + if self.add_pe: + self.pos_enc = PositionalEncoding( + self.embed_dim, + scale=self.pixel_pe_scale, + temperature=self.pixel_pe_temperature, + ) + + self.input_proj = nn.Linear(self.value_dim, self.embed_dim) + self.feature_pred = nn.Sequential( + nn.Linear(self.embed_dim, self.embed_dim), + nn.ReLU(inplace=True), + nn.Linear(self.embed_dim, self.embed_dim), + ) + self.weights_pred = nn.Sequential( + nn.Linear(self.embed_dim, self.embed_dim), + nn.ReLU(inplace=True), + nn.Linear(self.embed_dim, self.num_summaries), + ) + + def forward( + self, + masks: torch.Tensor, + value: torch.Tensor, + need_weights: bool = False, + ) -> tuple: + h, w = value.shape[-2:] + masks = F.interpolate(masks, size=(h, w), mode="area") + masks = masks.unsqueeze(-1) + inv_masks = 1 - masks + repeated_masks = torch.cat( + [ + masks.expand(-1, -1, -1, -1, self.num_summaries // 2), + inv_masks.expand(-1, -1, -1, -1, self.num_summaries // 2), + ], + dim=-1, + ) + + value = value.permute(0, 1, 3, 4, 2) + value = self.input_proj(value) + if self.add_pe: + pe = self.pos_enc(value) + value = value + pe + + with safe_autocast(enabled=False): + value = value.float() + feature = self.feature_pred(value) + logits = self.weights_pred(value) + sums, area = _weighted_pooling(repeated_masks, feature, logits) + + summaries = torch.cat([sums, area], dim=-1) + + if need_weights: + return summaries, logits + return summaries, None diff --git a/src/matanyone2/model/transformer/object_transformer.py b/src/matanyone2/model/transformer/object_transformer.py new file mode 100644 index 0000000..bdee016 --- /dev/null +++ b/src/matanyone2/model/transformer/object_transformer.py @@ -0,0 +1,218 @@ +""" +Object query transformer for MatAnyone2. +""" + +from typing import Dict, Optional + +import torch +import torch.nn as nn +from omegaconf import DictConfig + +from ...utils.tensor_utils import aggregate +from ..group_modules import GConv2d +from .positional_encoding import PositionalEncoding +from .transformer_layers import FFN, CrossAttention, PixelFFN, SelfAttention + + +class QueryTransformerBlock(nn.Module): + """Single transformer block for object queries.""" + + def __init__(self, model_cfg: DictConfig): + super().__init__() + this_cfg = model_cfg.object_transformer + self.embed_dim = this_cfg.embed_dim + self.num_heads = this_cfg.num_heads + self.num_queries = this_cfg.num_queries + self.ff_dim = this_cfg.ff_dim + + self.read_from_pixel = CrossAttention( + self.embed_dim, + self.num_heads, + add_pe_to_qkv=this_cfg.read_from_pixel.add_pe_to_qkv, + ) + self.self_attn = SelfAttention( + self.embed_dim, + self.num_heads, + add_pe_to_qkv=this_cfg.query_self_attention.add_pe_to_qkv, + ) + self.ffn = FFN(self.embed_dim, self.ff_dim) + self.read_from_query = CrossAttention( + self.embed_dim, + self.num_heads, + add_pe_to_qkv=this_cfg.read_from_query.add_pe_to_qkv, + norm=this_cfg.read_from_query.output_norm, + ) + self.pixel_ffn = PixelFFN(self.embed_dim) + + def forward( + self, + x: torch.Tensor, + pixel: torch.Tensor, + query_pe: torch.Tensor, + pixel_pe: torch.Tensor, + attn_mask: torch.Tensor, + need_weights: bool = False, + ) -> tuple: + pixel_flat = pixel.flatten(3, 4).flatten(0, 1).transpose(1, 2).contiguous() + x, q_weights = self.read_from_pixel( + x, + pixel_flat, + query_pe, + pixel_pe, + attn_mask=attn_mask, + need_weights=need_weights, + ) + x = self.self_attn(x, query_pe) + x = self.ffn(x) + + pixel_flat, p_weights = self.read_from_query( + pixel_flat, x, pixel_pe, query_pe, need_weights=need_weights + ) + pixel = self.pixel_ffn(pixel, pixel_flat) + + if need_weights: + bs, num_objects, _, h, w = pixel.shape + q_weights = q_weights.view( + bs, num_objects, self.num_heads, self.num_queries, h, w + ) + p_weights = p_weights.transpose(2, 3).view( + bs, num_objects, self.num_heads, self.num_queries, h, w + ) + + return x, pixel, q_weights, p_weights + + +class QueryTransformer(nn.Module): + """Query transformer for object-level segmentation.""" + + def __init__(self, model_cfg: DictConfig): + super().__init__() + this_cfg = model_cfg.object_transformer + self.value_dim = model_cfg.value_dim + self.embed_dim = this_cfg.embed_dim + self.num_heads = this_cfg.num_heads + self.num_queries = this_cfg.num_queries + + self.query_init = nn.Embedding(self.num_queries, self.embed_dim) + self.query_emb = nn.Embedding(self.num_queries, self.embed_dim) + self.summary_to_query_init = nn.Linear(self.embed_dim, self.embed_dim) + self.summary_to_query_emb = nn.Linear(self.embed_dim, self.embed_dim) + + self.pixel_pe_scale = model_cfg.pixel_pe_scale + self.pixel_pe_temperature = model_cfg.pixel_pe_temperature + self.pixel_init_proj = GConv2d(self.embed_dim, self.embed_dim, kernel_size=1) + self.pixel_emb_proj = GConv2d(self.embed_dim, self.embed_dim, kernel_size=1) + self.spatial_pe = PositionalEncoding( + self.embed_dim, + scale=self.pixel_pe_scale, + temperature=self.pixel_pe_temperature, + channel_last=False, + transpose_output=True, + ) + + self.num_blocks = this_cfg.num_blocks + self.blocks = nn.ModuleList( + QueryTransformerBlock(model_cfg) for _ in range(self.num_blocks) + ) + self.mask_pred = nn.ModuleList( + nn.Sequential(nn.ReLU(), GConv2d(self.embed_dim, 1, kernel_size=1)) + for _ in range(self.num_blocks + 1) + ) + + self.act = nn.ReLU(inplace=True) + + def forward( + self, + pixel: torch.Tensor, + obj_summaries: torch.Tensor, + selector: Optional[torch.Tensor] = None, + need_weights: bool = False, + seg_pass=False, + ) -> tuple: + T = obj_summaries.shape[2] + bs, num_objects, _, H, W = pixel.shape + + obj_summaries = obj_summaries.view( + bs * num_objects, T, self.num_queries, self.embed_dim + 1 + ) + obj_sums = obj_summaries[:, :, :, :-1].sum(dim=1) + obj_area = obj_summaries[:, :, :, -1:].sum(dim=1) + obj_values = obj_sums / (obj_area + 1e-4) + obj_init = self.summary_to_query_init(obj_values) + obj_emb = self.summary_to_query_emb(obj_values) + + query = ( + self.query_init.weight.unsqueeze(0).expand(bs * num_objects, -1, -1) + + obj_init + ) + query_emb = ( + self.query_emb.weight.unsqueeze(0).expand(bs * num_objects, -1, -1) + + obj_emb + ) + + pixel_init = self.pixel_init_proj(pixel) + pixel_emb = self.pixel_emb_proj(pixel) + pixel_pe = self.spatial_pe(pixel.flatten(0, 1)) + pixel_emb = pixel_emb.flatten(3, 4).flatten(0, 1).transpose(1, 2).contiguous() + pixel_pe = pixel_pe.flatten(1, 2) + pixel_emb + + pixel = pixel_init + + aux_features = {"logits": []} + aux_logits = self.mask_pred[0](pixel).squeeze(2) + attn_mask = self._get_aux_mask(aux_logits, selector, seg_pass=seg_pass) + aux_features["logits"].append(aux_logits) + + for i in range(self.num_blocks): + query, pixel, q_weights, p_weights = self.blocks[i]( + query, pixel, query_emb, pixel_pe, attn_mask, need_weights=need_weights + ) + if self.training or i <= self.num_blocks - 1 or need_weights: + aux_logits = self.mask_pred[i + 1](pixel).squeeze(2) + attn_mask = self._get_aux_mask(aux_logits, selector, seg_pass=seg_pass) + aux_features["logits"].append(aux_logits) + + aux_features["q_weights"] = q_weights + aux_features["p_weights"] = p_weights + + if self.training: + aux_features["attn_mask"] = attn_mask.view( + bs, num_objects, self.num_heads, self.num_queries, H, W + )[:, :, 0] + + return pixel, aux_features + + def _get_aux_mask( + self, + logits: torch.Tensor, + selector: torch.Tensor, + seg_pass=False, + ) -> torch.Tensor: + if selector is None: + prob = logits.sigmoid() + else: + prob = logits.sigmoid() * selector + logits = aggregate(prob, dim=1) + + is_foreground = logits[:, 1:] >= logits.max(dim=1, keepdim=True)[0] + foreground_mask = is_foreground.bool().flatten(start_dim=2) + inv_foreground_mask = ~foreground_mask + inv_background_mask = foreground_mask + + aux_foreground_mask = ( + inv_foreground_mask.unsqueeze(2) + .unsqueeze(2) + .repeat(1, 1, self.num_heads, self.num_queries // 2, 1) + .flatten(start_dim=0, end_dim=2) + ) + aux_background_mask = ( + inv_background_mask.unsqueeze(2) + .unsqueeze(2) + .repeat(1, 1, self.num_heads, self.num_queries // 2, 1) + .flatten(start_dim=0, end_dim=2) + ) + + aux_mask = torch.cat([aux_foreground_mask, aux_background_mask], dim=1) + aux_mask[torch.where(aux_mask.sum(-1) == aux_mask.shape[-1])] = False + + return aux_mask diff --git a/src/matanyone2/model/transformer/positional_encoding.py b/src/matanyone2/model/transformer/positional_encoding.py new file mode 100644 index 0000000..1728ff7 --- /dev/null +++ b/src/matanyone2/model/transformer/positional_encoding.py @@ -0,0 +1,93 @@ +""" +Positional encoding for MatAnyone2 transformer. +""" + +import math + +import numpy as np +import torch +from torch import nn + +from ...utils.device import get_default_device + + +def get_emb(sin_inp: torch.Tensor) -> torch.Tensor: + """Gets base embedding for one dimension with sin and cos intertwined.""" + emb = torch.stack((sin_inp.sin(), sin_inp.cos()), dim=-1) + return torch.flatten(emb, -2, -1) + + +class PositionalEncoding(nn.Module): + """Sinusoidal positional encoding for 2D features.""" + + def __init__( + self, + dim: int, + scale: float = math.pi * 2, + temperature: float = 10000, + normalize: bool = True, + channel_last: bool = True, + transpose_output: bool = False, + ): + super().__init__() + dim = int(np.ceil(dim / 4) * 2) + self.dim = dim + inv_freq = 1.0 / (temperature ** (torch.arange(0, dim, 2).float() / dim)) + self.register_buffer("inv_freq", inv_freq) + self.normalize = normalize + self.scale = scale + self.eps = 1e-6 + self.channel_last = channel_last + self.transpose_output = transpose_output + self.cached_penc = None + + def forward(self, tensor: torch.Tensor) -> torch.Tensor: + if len(tensor.shape) not in (4, 5): + raise RuntimeError( + "The input tensor has to be 4/5d, got %s!" % tensor.shape + ) + + if len(tensor.shape) == 5: + num_objects = tensor.shape[1] + tensor = tensor[:, 0] + else: + num_objects = None + + if self.channel_last: + batch_size, h, w, c = tensor.shape + else: + batch_size, c, h, w = tensor.shape + + if self.cached_penc is not None and self.cached_penc.shape == tensor.shape: + if num_objects is None: + return self.cached_penc + return self.cached_penc.unsqueeze(1) + + self.cached_penc = None + + pos_y = torch.arange(h, device=tensor.device, dtype=self.inv_freq.dtype) + pos_x = torch.arange(w, device=tensor.device, dtype=self.inv_freq.dtype) + if self.normalize: + pos_y = pos_y / (pos_y[-1] + self.eps) * self.scale + pos_x = pos_x / (pos_x[-1] + self.eps) * self.scale + + sin_inp_y = torch.einsum("i,j->ij", pos_y, self.inv_freq) + sin_inp_x = torch.einsum("i,j->ij", pos_x, self.inv_freq) + emb_y = get_emb(sin_inp_y).unsqueeze(1) + emb_x = get_emb(sin_inp_x) + + emb = torch.zeros( + (h, w, self.dim * 2), device=tensor.device, dtype=tensor.dtype + ) + emb[:, :, : self.dim] = emb_x + emb[:, :, self.dim :] = emb_y + + if not self.channel_last and self.transpose_output: + pass + elif (not self.channel_last) or self.transpose_output: + emb = emb.permute(2, 0, 1) + + self.cached_penc = emb.unsqueeze(0).repeat(batch_size, 1, 1, 1) + if num_objects is None: + return self.cached_penc + return self.cached_penc.unsqueeze(1) diff --git a/src/matanyone2/model/transformer/transformer_layers.py b/src/matanyone2/model/transformer/transformer_layers.py new file mode 100644 index 0000000..a6109d9 --- /dev/null +++ b/src/matanyone2/model/transformer/transformer_layers.py @@ -0,0 +1,182 @@ +""" +Transformer layers for MatAnyone2. +""" + +from typing import Callable, List + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch import Tensor + +from ..channel_attn import CAResBlock + + +class SelfAttention(nn.Module): + """Self-attention with optional positional encoding.""" + + def __init__( + self, + dim: int, + nhead: int, + dropout: float = 0.0, + batch_first: bool = True, + add_pe_to_qkv: List[bool] = None, + ): + super().__init__() + if add_pe_to_qkv is None: + add_pe_to_qkv = [True, True, False] + self.self_attn = nn.MultiheadAttention( + dim, nhead, dropout=dropout, batch_first=batch_first + ) + self.norm = nn.LayerNorm(dim) + self.dropout = nn.Dropout(dropout) + self.add_pe_to_qkv = add_pe_to_qkv + + def forward( + self, + x: torch.Tensor, + pe: torch.Tensor, + attn_mask: bool = None, + key_padding_mask: bool = None, + ) -> torch.Tensor: + x = self.norm(x) + if any(self.add_pe_to_qkv): + x_with_pe = x + pe + q = x_with_pe if self.add_pe_to_qkv[0] else x + k = x_with_pe if self.add_pe_to_qkv[1] else x + v = x_with_pe if self.add_pe_to_qkv[2] else x + else: + q = k = v = x + + r = x + x = self.self_attn( + q, k, v, attn_mask=attn_mask, key_padding_mask=key_padding_mask + )[0] + return r + self.dropout(x) + + +class CrossAttention(nn.Module): + """Cross-attention with optional positional encoding.""" + + def __init__( + self, + dim: int, + nhead: int, + dropout: float = 0.0, + batch_first: bool = True, + add_pe_to_qkv: List[bool] = None, + residual: bool = True, + norm: bool = True, + ): + super().__init__() + if add_pe_to_qkv is None: + add_pe_to_qkv = [True, True, False] + self.cross_attn = nn.MultiheadAttention( + dim, nhead, dropout=dropout, batch_first=batch_first + ) + self.norm = nn.LayerNorm(dim) if norm else nn.Identity() + self.dropout = nn.Dropout(dropout) + self.add_pe_to_qkv = add_pe_to_qkv + self.residual = residual + + def forward( + self, + x: torch.Tensor, + mem: torch.Tensor, + x_pe: torch.Tensor, + mem_pe: torch.Tensor, + attn_mask: bool = None, + *, + need_weights: bool = False, + ) -> tuple: + x = self.norm(x) + if self.add_pe_to_qkv[0]: + q = x + x_pe + else: + q = x + + if any(self.add_pe_to_qkv[1:]): + mem_with_pe = mem + mem_pe + k = mem_with_pe if self.add_pe_to_qkv[1] else mem + v = mem_with_pe if self.add_pe_to_qkv[2] else mem + else: + k = v = mem + + r = x + x, weights = self.cross_attn( + q, + k, + v, + attn_mask=attn_mask, + need_weights=need_weights, + average_attn_weights=False, + ) + + if self.residual: + return r + self.dropout(x), weights + return self.dropout(x), weights + + +class FFN(nn.Module): + """Feed-forward network.""" + + def __init__(self, dim_in: int, dim_ff: int, activation=F.relu): + super().__init__() + self.linear1 = nn.Linear(dim_in, dim_ff) + self.linear2 = nn.Linear(dim_ff, dim_in) + self.norm = nn.LayerNorm(dim_in) + self.activation = ( + _get_activation_fn(activation) + if isinstance(activation, str) + else activation + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + r = x + x = self.norm(x) + x = self.linear2(self.activation(self.linear1(x))) + return r + x + + +class PixelFFN(nn.Module): + """Pixel-level feed-forward using CAResBlock.""" + + def __init__(self, dim: int): + super().__init__() + self.dim = dim + self.conv = CAResBlock(dim, dim) + + def forward(self, pixel: torch.Tensor, pixel_flat: torch.Tensor) -> torch.Tensor: + bs, num_objects, _, h, w = pixel.shape + pixel_flat = pixel_flat.view(bs * num_objects, h, w, self.dim) + pixel_flat = pixel_flat.permute(0, 3, 1, 2).contiguous() + x = self.conv(pixel_flat) + x = x.view(bs, num_objects, self.dim, h, w) + return x + + +class OutputFFN(nn.Module): + """Output projection FFN.""" + + def __init__(self, dim_in: int, dim_out: int, activation=F.relu): + super().__init__() + self.linear1 = nn.Linear(dim_in, dim_out) + self.linear2 = nn.Linear(dim_out, dim_out) + self.activation = ( + _get_activation_fn(activation) + if isinstance(activation, str) + else activation + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.linear2(self.activation(self.linear1(x))) + return x + + +def _get_activation_fn(activation: str) -> Callable[[Tensor], Tensor]: + if activation == "relu": + return F.relu + if activation == "gelu": + return F.gelu + raise RuntimeError("activation should be relu/gelu, not %s" % activation) diff --git a/src/matanyone2/model/utils/__init__.py b/src/matanyone2/model/utils/__init__.py new file mode 100644 index 0000000..be24488 --- /dev/null +++ b/src/matanyone2/model/utils/__init__.py @@ -0,0 +1,4 @@ +"""MatAnyone2 model utilities.""" +from . import resnet + +__all__ = ["resnet"] diff --git a/src/matanyone2/model/utils/memory_utils.py b/src/matanyone2/model/utils/memory_utils.py new file mode 100644 index 0000000..63b1fc8 --- /dev/null +++ b/src/matanyone2/model/utils/memory_utils.py @@ -0,0 +1,111 @@ +""" +Memory utilities for MatAnyone2 (similarity, softmax, affinity, readout). +""" + +import math +from typing import Optional, Tuple, Union + +import torch + + +def get_similarity( + mk: torch.Tensor, + ms: torch.Tensor, + qk: torch.Tensor, + qe: torch.Tensor, + add_batch_dim: bool = False, + uncert_mask=None, +) -> torch.Tensor: + """Computes similarity for memory reading.""" + if add_batch_dim: + mk, ms = mk.unsqueeze(0), ms.unsqueeze(0) + qk, qe = qk.unsqueeze(0), qe.unsqueeze(0) + + CK = mk.shape[1] + + mk = mk.flatten(start_dim=2) + ms = ms.flatten(start_dim=1).unsqueeze(2) if ms is not None else None + qk = qk.flatten(start_dim=2) + qe = qe.flatten(start_dim=2) if qe is not None else None + + if uncert_mask is not None: + uncert_mask = uncert_mask.flatten(start_dim=2) + uncert_mask = uncert_mask.expand(-1, 64, -1) + qk = qk * uncert_mask + qe = qe * uncert_mask + + if qe is not None: + mk = mk.transpose(1, 2) + a_sq = mk.pow(2) @ qe + two_ab = 2 * (mk @ (qk * qe)) + b_sq = (qe * qk.pow(2)).sum(1, keepdim=True) + similarity = -a_sq + two_ab - b_sq + else: + a_sq = mk.pow(2).sum(1).unsqueeze(2) + two_ab = 2 * (mk.transpose(1, 2) @ qk) + similarity = -a_sq + two_ab + + if ms is not None: + similarity = similarity * ms / math.sqrt(CK) + else: + similarity = similarity / math.sqrt(CK) + + return similarity + + +def do_softmax( + similarity: torch.Tensor, + top_k: Optional[int] = None, + inplace: bool = False, + return_usage: bool = False, +) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + """Normalizes similarity with top-k softmax.""" + if top_k is not None: + values, indices = torch.topk(similarity, k=top_k, dim=1) + x_exp = values.exp_() + x_exp /= torch.sum(x_exp, dim=1, keepdim=True) + if inplace: + similarity.zero_().scatter_(1, indices, x_exp) + affinity = similarity + else: + affinity = torch.zeros_like(similarity).scatter_(1, indices, x_exp) + else: + maxes = torch.max(similarity, dim=1, keepdim=True)[0] + x_exp = torch.exp(similarity - maxes) + x_exp_sum = torch.sum(x_exp, dim=1, keepdim=True) + affinity = x_exp / x_exp_sum + indices = None + + if return_usage: + return affinity, affinity.sum(dim=2) + + return affinity + + +def get_affinity( + mk: torch.Tensor, + ms: torch.Tensor, + qk: torch.Tensor, + qe: torch.Tensor, + uncert_mask=None, +) -> torch.Tensor: + """Shorthand for get_similarity + do_softmax.""" + similarity = get_similarity(mk, ms, qk, qe, uncert_mask=uncert_mask) + affinity = do_softmax(similarity) + return affinity + + +def readout( + affinity: torch.Tensor, + mv: torch.Tensor, + uncert_mask: torch.Tensor = None, +) -> torch.Tensor: + """Reads memory values using affinity.""" + B, CV, T, H, W = mv.shape + mo = mv.view(B, CV, T * H * W) + mem = torch.bmm(mo, affinity) + if uncert_mask is not None: + uncert_mask = uncert_mask.flatten(start_dim=2).expand(-1, CV, -1) + mem = mem * uncert_mask + mem = mem.view(B, CV, H, W) + return mem diff --git a/src/matanyone2/model/utils/parameter_groups.py b/src/matanyone2/model/utils/parameter_groups.py new file mode 100644 index 0000000..24beec4 --- /dev/null +++ b/src/matanyone2/model/utils/parameter_groups.py @@ -0,0 +1,66 @@ +""" +Parameter group utilities for MatAnyone2 training. +""" + +import logging + +log = logging.getLogger() + + +def get_parameter_groups(model, stage_cfg, print_log=False): + """ + Assigns different weight decays and learning rates to different parameters. + Returns parameter groups for optimizer. + """ + weight_decay = stage_cfg.weight_decay + embed_weight_decay = stage_cfg.embed_weight_decay + backbone_lr_ratio = stage_cfg.backbone_lr_ratio + base_lr = stage_cfg.learning_rate + + backbone_params = [] + embed_params = [] + other_params = [] + + embedding_names = ["summary_pos", "query_init", "query_emb", "obj_pe"] + embedding_names = [e + ".weight" for e in embedding_names] + + memo = set() + for name, param in model.named_parameters(): + if not param.requires_grad: + continue + if param in memo: + continue + memo.add(param) + + if name.startswith("module"): + name = name[7:] + + inserted = False + if name.startswith("pixel_encoder."): + backbone_params.append(param) + inserted = True + if print_log: + log.info("%s counted as a backbone parameter.", name) + else: + for e in embedding_names: + if name.endswith(e): + embed_params.append(param) + inserted = True + if print_log: + log.info("%s counted as an embedding parameter.", name) + break + + if not inserted: + other_params.append(param) + + parameter_groups = [ + { + "params": backbone_params, + "lr": base_lr * backbone_lr_ratio, + "weight_decay": weight_decay, + }, + {"params": embed_params, "lr": base_lr, "weight_decay": embed_weight_decay}, + {"params": other_params, "lr": base_lr, "weight_decay": weight_decay}, + ] + + return parameter_groups diff --git a/src/matanyone2/model/utils/resnet.py b/src/matanyone2/model/utils/resnet.py new file mode 100644 index 0000000..185e05b --- /dev/null +++ b/src/matanyone2/model/utils/resnet.py @@ -0,0 +1,186 @@ +""" +Modified ResNet structure for MatAnyone2. +Appends extra channels to the first conv for mask input. +""" + +import math +from collections import OrderedDict + +import torch +import torch.nn as nn + +try: + from torch.hub import load_state_dict_from_url +except ImportError: + from torch.utils.model_zoo import ( + load_url as load_state_dict_from_url, # type: ignore + ) + + +def load_weights_add_extra_dim(target, source_state, extra_dim=1): + """Loads weights, adding extra input channels if needed.""" + new_dict = OrderedDict() + + for k1, v1 in target.state_dict().items(): + if "num_batches_tracked" not in k1: + if k1 in source_state: + tar_v = source_state[k1] + + if v1.shape != tar_v.shape: + c, _, w, h = v1.shape + pads = torch.zeros((c, extra_dim, w, h), device=tar_v.device) + nn.init.orthogonal_(pads) + tar_v = torch.cat([tar_v, pads], 1) + + new_dict[k1] = tar_v + + target.load_state_dict(new_dict) + + +MODEL_URLS = { + "resnet18": "https://download.pytorch.org/models/resnet18-5c106cde.pth", + "resnet50": "https://download.pytorch.org/models/resnet50-19c8e357.pth", +} + + +def conv3x3(in_planes, out_planes, stride=1, dilation=1): + """3x3 convolution with padding.""" + return nn.Conv2d( + in_planes, + out_planes, + kernel_size=3, + stride=stride, + padding=dilation, + dilation=dilation, + bias=False, + ) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None, dilation=1): + super().__init__() + self.conv1 = conv3x3(inplanes, planes, stride=stride, dilation=dilation) + self.bn1 = nn.BatchNorm2d(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3(planes, planes, stride=1, dilation=dilation) + self.bn2 = nn.BatchNorm2d(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + out = self.conv2(out) + out = self.bn2(out) + if self.downsample is not None: + residual = self.downsample(x) + out += residual + out = self.relu(out) + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None, dilation=1): + super().__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.conv2 = nn.Conv2d( + planes, + planes, + kernel_size=3, + stride=stride, + dilation=dilation, + padding=dilation, + bias=False, + ) + self.bn2 = nn.BatchNorm2d(planes) + self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * 4) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + out = self.conv3(out) + out = self.bn3(out) + if self.downsample is not None: + residual = self.downsample(x) + out += residual + out = self.relu(out) + return out + + +class ResNet(nn.Module): + """ResNet backbone with optional extra input channels.""" + + def __init__(self, block, layers=(3, 4, 23, 3), extra_dim=0): + super().__init__() + self.inplanes = 64 + self.conv1 = nn.Conv2d( + 3 + extra_dim, 64, kernel_size=7, stride=2, padding=3, bias=False + ) + self.bn1 = nn.BatchNorm2d(64) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + self.layer1 = self._make_layer(block, 64, layers[0]) + self.layer2 = self._make_layer(block, 128, layers[1], stride=2) + self.layer3 = self._make_layer(block, 256, layers[2], stride=2) + self.layer4 = self._make_layer(block, 512, layers[3], stride=2) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2.0 / n)) + elif isinstance(m, nn.BatchNorm2d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, stride=1, dilation=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d( + self.inplanes, + planes * block.expansion, + kernel_size=1, + stride=stride, + bias=False, + ), + nn.BatchNorm2d(planes * block.expansion), + ) + layers = [block(self.inplanes, planes, stride, downsample)] + self.inplanes = planes * block.expansion + for _ in range(1, blocks): + layers.append(block(self.inplanes, planes, dilation=dilation)) + return nn.Sequential(*layers) + + +def resnet18(pretrained=True, extra_dim=0): + """Build ResNet-18.""" + model = ResNet(BasicBlock, [2, 2, 2, 2], extra_dim) + if pretrained: + state = load_state_dict_from_url(MODEL_URLS["resnet18"]) + load_weights_add_extra_dim(model, state, extra_dim) + return model + + +def resnet50(pretrained=True, extra_dim=0): + """Build ResNet-50.""" + model = ResNet(Bottleneck, [3, 4, 6, 3], extra_dim) + if pretrained: + state = load_state_dict_from_url(MODEL_URLS["resnet50"]) + load_weights_add_extra_dim(model, state, extra_dim) + return model diff --git a/src/matanyone2/utils/__init__.py b/src/matanyone2/utils/__init__.py new file mode 100644 index 0000000..4e3fae9 --- /dev/null +++ b/src/matanyone2/utils/__init__.py @@ -0,0 +1 @@ +"""MatAnyone2 utilities.""" diff --git a/src/matanyone2/utils/device.py b/src/matanyone2/utils/device.py new file mode 100644 index 0000000..6714a35 --- /dev/null +++ b/src/matanyone2/utils/device.py @@ -0,0 +1,47 @@ +""" +Device utilities for MatAnyone2 inference. +""" + +import contextlib +import functools + +import torch + + +def get_default_device(): + """Returns CUDA, MPS, or CPU device based on availability.""" + if torch.cuda.is_available(): + return torch.device("cuda") + elif torch.backends.mps.is_built() and torch.backends.mps.is_available(): + return torch.device("mps") + else: + return torch.device("cpu") + + +def safe_autocast_decorator(enabled=True): + """Decorator for safe autocast on CUDA/CPU (skips MPS).""" + + def decorator(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + device = get_default_device() + if device.type in ["cuda", "cpu"]: + with torch.amp.autocast(device_type=device.type, enabled=enabled): + return func(*args, **kwargs) + else: + return func(*args, **kwargs) + + return wrapper + + return decorator + + +@contextlib.contextmanager +def safe_autocast(enabled=True): + """Context manager for safe autocast on CUDA/CPU (skips MPS).""" + device = get_default_device() + if device.type in ["cuda", "cpu"]: + with torch.amp.autocast(device_type=device.type, enabled=enabled): + yield + else: + yield diff --git a/src/matanyone2/utils/get_default_model.py b/src/matanyone2/utils/get_default_model.py new file mode 100644 index 0000000..f0269ba --- /dev/null +++ b/src/matanyone2/utils/get_default_model.py @@ -0,0 +1,43 @@ +""" +Loads MatAnyone2 model from checkpoint. +""" + +from pathlib import Path + +import torch +from omegaconf import OmegaConf, open_dict + +from ..model.matanyone2 import MatAnyone2 + + +def get_matanyone2_model(ckpt_path: str, device=None) -> MatAnyone2: + """Loads MatAnyone2 model from checkpoint path.""" + config_dir = Path(__file__).resolve().parent.parent / "config" + + # Load base model config and eval config + model_cfg = OmegaConf.load(config_dir / "model" / "base.yaml") + eval_cfg = OmegaConf.load(config_dir / "eval_matanyone_config.yaml") + + # Clean up hydra/defaults from eval_cfg if they exist + if "defaults" in eval_cfg: + del eval_cfg["defaults"] + if "hydra" in eval_cfg: + del eval_cfg["hydra"] + + # Merge them manually as hydra did + cfg = OmegaConf.merge(eval_cfg, {"model": model_cfg}) + OmegaConf.resolve(cfg) + + with open_dict(cfg): + cfg["weights"] = ckpt_path + + if device is not None: + matanyone2 = MatAnyone2(cfg, single_object=True).to(device).eval() + model_weights = torch.load(cfg.weights, map_location=device) + else: + matanyone2 = MatAnyone2(cfg, single_object=True).cuda().eval() + model_weights = torch.load(cfg.weights) + + matanyone2.load_weights(model_weights) + + return matanyone2 diff --git a/src/matanyone2/utils/inference_utils.py b/src/matanyone2/utils/inference_utils.py new file mode 100644 index 0000000..e1dea0a --- /dev/null +++ b/src/matanyone2/utils/inference_utils.py @@ -0,0 +1,69 @@ +""" +Inference utilities for MatAnyone2 (erosion, dilation, frame loading). +""" + +import os +import random + +import cv2 +import numpy as np +import torch +import torchvision + +IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".JPG", ".JPEG", ".PNG") +VIDEO_EXTENSIONS = (".mp4", ".mov", ".avi", ".MP4", ".MOV", ".AVI") + + +def read_frame_from_videos(frame_root): + """Reads frames from video file or image folder. Returns (frames, fps, length, name).""" + if frame_root.endswith(VIDEO_EXTENSIONS): + video_name = os.path.basename(frame_root)[:-4] + frames, _, info = torchvision.io.read_video( + filename=frame_root, pts_unit="sec", output_format="TCHW" + ) + fps = info["video_fps"] + else: + video_name = os.path.basename(frame_root) + frames = [] + fr_lst = sorted(os.listdir(frame_root)) + for fr in fr_lst: + frame = cv2.imread(os.path.join(frame_root, fr))[..., [2, 1, 0]] + frames.append(frame) + fps = 24 + frames = torch.Tensor(np.array(frames)).permute(0, 3, 1, 2).contiguous() + + length = frames.shape[0] + return frames, fps, length, video_name + + +def get_video_paths(input_root): + """Collects video file paths under input_root.""" + video_paths = [] + for root, _, files in os.walk(input_root): + for file in files: + if file.lower().endswith(VIDEO_EXTENSIONS): + video_paths.append(os.path.join(root, file)) + return sorted(video_paths) + + +def str_to_list(value): + """Parses comma-separated string to list of ints.""" + return list(map(int, value.split(","))) + + +def gen_dilate(alpha, min_kernel_size, max_kernel_size): + """Dilates alpha mask with random kernel size.""" + kernel_size = random.randint(min_kernel_size, max_kernel_size) + kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size)) + fg_and_unknown = np.array(np.not_equal(alpha, 0).astype(np.float32)) + dilate = cv2.dilate(fg_and_unknown, kernel, iterations=1) * 255 + return dilate.astype(np.float32) + + +def gen_erosion(alpha, min_kernel_size, max_kernel_size): + """Erodes alpha mask with random kernel size.""" + kernel_size = random.randint(min_kernel_size, max_kernel_size) + kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size)) + fg = np.array(np.equal(alpha, 255).astype(np.float32)) + erode = cv2.erode(fg, kernel, iterations=1) * 255 + return erode.astype(np.float32) diff --git a/src/matanyone2/utils/tensor_utils.py b/src/matanyone2/utils/tensor_utils.py new file mode 100644 index 0000000..628eb27 --- /dev/null +++ b/src/matanyone2/utils/tensor_utils.py @@ -0,0 +1,71 @@ +""" +Tensor utilities for MatAnyone2. +""" + +from typing import Iterable, List + +import torch +import torch.nn.functional as F + +from .device import safe_autocast + + +def pad_divide_by(in_img: torch.Tensor, d: int) -> tuple[torch.Tensor, Iterable[int]]: + """Pads image so dimensions are divisible by d.""" + h, w = in_img.shape[-2:] + + if h % d > 0: + new_h = h + d - h % d + else: + new_h = h + if w % d > 0: + new_w = w + d - w % d + else: + new_w = w + lh, uh = int((new_h - h) / 2), int(new_h - h) - int((new_h - h) / 2) + lw, uw = int((new_w - w) / 2), int(new_w - w) - int((new_w - w) / 2) + pad_array = (int(lw), int(uw), int(lh), int(uh)) + out = F.pad(in_img, pad_array) + return out, pad_array + + +def unpad(img: torch.Tensor, pad: Iterable[int]) -> torch.Tensor: + """Removes padding from image.""" + if len(img.shape) == 4: + if pad[2] + pad[3] > 0: + img = img[:, :, pad[2] : -pad[3], :] + if pad[0] + pad[1] > 0: + img = img[:, :, :, pad[0] : -pad[1]] + elif len(img.shape) == 3: + if pad[2] + pad[3] > 0: + img = img[:, pad[2] : -pad[3], :] + if pad[0] + pad[1] > 0: + img = img[:, :, pad[0] : -pad[1]] + elif len(img.shape) == 5: + if pad[2] + pad[3] > 0: + img = img[:, :, :, pad[2] : -pad[3], :] + if pad[0] + pad[1] > 0: + img = img[:, :, :, :, pad[0] : -pad[1]] + else: + raise NotImplementedError + return img + + +def aggregate(prob: torch.Tensor, dim: int) -> torch.Tensor: + """Aggregates probability tensor along dimension.""" + with safe_autocast(enabled=False): + prob = prob.float() + new_prob = torch.cat( + [torch.prod(1 - prob, dim=dim, keepdim=True), prob], dim + ).clamp(1e-7, 1 - 1e-7) + logits = torch.log((new_prob / (1 - new_prob))) + return logits + + +def cls_to_one_hot(cls_gt: torch.Tensor, num_objects: int) -> torch.Tensor: + """Converts class indices to one-hot encoding.""" + B, _, H, W = cls_gt.shape + one_hot = torch.zeros(B, num_objects + 1, H, W, device=cls_gt.device).scatter_( + 1, cls_gt, 1 + ) + return one_hot diff --git a/workflow/mat_anyone_preview_v2.png b/workflow/mat_anyone_preview_v2.png new file mode 100644 index 0000000000000000000000000000000000000000..1e18c05a27513aceed9e01f17b8db88c2e587e72 GIT binary patch literal 275202 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

bs zJ(vs+e*HT6AkH{+LMny&F?V3rQCl&C(_BS$q+xeHoW4Lb#m4 zwG=Y32sLF9&^q@HQ& z@RA3D-pG>0wf+0ktiAWBXZ2HGbLVZ$`fc*B_3M2huk$3|hbnH}$1|apD*-?xMeVxx z_I>_Iy1qX4DSkU4A*$MUC)l-Xhr;(I8C9lP>Vb+JMTZ+hu@>$EE;GjZA&_VVk#HIP zExJ|>bbG^ekz>xkbqwlCqNi8YCMDi**zkF{&Wy{_j)ti3Ngva zITBB3kEG9+DhvJyEI`0Zy}jN4M%{=5{gDNX=?gINP2jT%-IoJ&?v{Q7AJ}MtyCvYh z^}8ro@+$kj;~-hv?r|IF**yahOpf~uo(NFuZoG9>D@=V!mdlFGXW;5|q}lS@Z0*^{ zy9t&F{&S=Yf+q_4-TlH+UDUSlLdo*(gGr|z>`ETvCjLyY^jBG3CTRc?5g=WZZP_O- zZAQQwnOR}pNNHURvg8wn<;-ch1a28+PimEdysW&OK_f8L)S9gl0;7JOn*x#}Gjpb0 znzH_7!0%n{upH_`wQadyZ@gctcX@4#`s^CHP)q=B73^h{Tx>8wDUF8_ToNX$YRQ!l z7Z(;nGB&+GdH%9Td@uMiMM21Iv)p2MT#UTRWxub*(PjL+G(6nm=0Groum-p8q`>Bv zPT@&gc;!N2kO-#%<7a_qtiB^vc`4X!?%1sh?rm12Vrf&}WcU1FF*_$WA}w|A9&Vr} z{>k9mK81aL+hO5oF`Ld^Gzt3o0J{J=j@eHKU{6|)Ie28ttNd%nq#6+g5K6Yg8<3^j z91{DSE(R$C>P!Kpj@H5H~J z>fG>Ys*gdA^HpU!pm_C>@Ot;$U7Uhuq2LpAt&G%_sIXciw2WoAjEQm5`ih%Yj$D1P zf_$6ps#OMe2_ZKPAvYBv7uTX~Y6Z=-8k20gX1Zxq@X3I z<0wA8_B)+vRtIwV@5jb^rl&zut20VK<}&Z&DveRfZ>xFwyL-SQ>a`I@Z1LP<(3hUL zh_d&hpb>%urh!GRC^^1W>mh%s7e4?tN-u{<0Zhw5Z^K~ME){bR98N3?6f|7WLMe#- z9S&{P_c6tn?nVe`woP~3tyo7;%Q+h1maxKqQLt>|836*sxEqc`#1~UQju=Wur`_dr z()aD!sxcfo@FOeb3p89efDpHaUri(@HN9LOi!T8Yk=OF5-UqPUmCJ5dHP&=l^c6oY z?YCk*X9Tf?9wa108I3vBwv=KSdQ?Az95r=`gd|Og6v5L}0QfM+yj#;*tQM^k1 zXIE+J@qT|AydtB{ZwDR9g!QAY@p+jwKNY(p8nq~-RdRLHsUzhQ`b#vEul}fX%fy?N z5t8Pt)VZ%VF@0{bCthyxIUWQip6&m#aw=z}rB;KtBYRaDcmGjm? znlD=+KY!H7H-UW!w_hgm8bZqOI3Od|boM;CUIXrZC%#3a;_LMq(`+xW>r;Suzcj_q zKh%7+q(}-F#D$s~o{}p-TLq|pva*G=#L7D`4E5sRgY^~T=WGC7E+yYhNYc$m3Jm8Z zbBbjl2A@7oUNlB3U3)Z!Yw_tPjA#wMA2NUUq5j*PKxQuyBZwMVgLCNeO^sk$T@KW95p1 zXMs*tp}Kznpqb3RO<@$$as0mDca7Cqj)VAcym|(rslbKr_QO8Y-Y7AEa{wsUryqmz z-4~U|=D7xWX00VT-(9CY&p1Wxo)>}8gm*C|MyA1Hn zUD58ALg$G8ie;g3@e}G`uo$vy7uU z>3r#`35~V2bQa(9fj4PpYH3W=0`=fA=1!Cc6I1E5RDv1auF8Qw99iI)Da-B~#sNPt zJCo*SAEl9;X3RFOaybDfSQgI$#k@^MPpAm!CT7tT`r{+gW~phP&cy zosiKAQfC&zZsM|}1&$mY-z`*0*OxW8<82gA0vQyg8>#2BEF0_!o9qsD@4~46EeEH{ zjVOC4rG2}F2-57h?|AeY>{vjWDiG$h7hfhM2)9}%#fdwXlDZ=|D*MzapguZNJM)P& zcoqRxlK)F8q$pcL>Us!COnT{0ZfelLo(vU`5mqtz6!k~BsAOhiLzQXhk^fLJ0YhaV z=5IwE3!JC3@J*1k+bV^)a{o}Vn$eKa4i5xN9c@7x=lBwJQR%Yw-Ci9#)Bv8T-Y=1! z;GHzygAOPRYPINdl9DI&f4lvfu|V8>ci(k{DkanR?a>L}1QY&J_^fUel;P+kjxvt7 zWS5}K?x8JDZF_lbIK_Op=ySSwXW)WbjMo*izN{#hOdkn>U;>(=^s__^b$6~oBR76R1uIx@b#>|^mx&#PwOP_ z;6cYGFJSVlJ=#6oVLG3KM@E_3Vm9Ag_mqA)yJEH2LdD<<(|;X0uFkA&YTJ z=@nvw=PsYur>xJeXFdK93TvL{ojTlFR$#v`FCAG}7_8vU*>62M(QvFVZ4DY@U5{Tw zyR%%^;g>w8BlK>5k~%+N41F}J&rnkLqA$`Wy@C~cuJ%Ty$v;`5oB#7%za~+zpKy;h zeoi)9ZL%%JhRs@EKo@JN?oYxocZk0(#Do9{O{iGW7MXwzgqWV>{f`zfXPOo=Ln#}NM7qg(%(jcqrvq`t=}rOS5;a4( z*Cftmhz0Aj2=X9+A-^;blkPO`y)^TVl-x_JHvLz4Uq&~diEsHQxYmS&F5@aUWq8Rg ze~XmBvg+@GMmxK^0Y|63=d1szYDRHg?HE@-wXl#OLIS+mPse=>@~5p-j~q$7{-08p z6WZ3|>S~mdl4VWwkh56-hZXy~*#jUV^cF0(z zYQ>BaerV?!V@WDUR$yrsP)Eppp1_z# z)pk_=v4g4e^0;YSLndf#)AKpoEU4GNDr1~_d2WI6gk-T&+ZA{P{RKMI>}S?Y#CG5p zYZ8P}LvIv^+kL&Fv9qg1Kk@w)fl?VwmNUj`#z&iapo2^pPeIG-a6#Mtby!lc4j^hh z0LC{C?>82b2w^a(z;5xn=x$y&t1~5*sShP}QP;Hx3zj&zcJ5imV1U{CpDYj&hILG; z|K-i|`ScF6tkYWG9a13xPeR})LLTB0Toa@`BrJFpRJ^XIJE{Si%i8SfIg3gqYaA}d z_q-s{rDWJ-+&+jsQCRvN%z3GJj{;3=4noUhzU2n@)#1a3!-w7BrMae4F>dQ zgCk{w5B_8Pt~PX41WziO0~%kYr?t2Le|dKbCB{5+n-r?75Dl0|Zy_ zpEmm_fAE@GrgLP7q=Hv>>#aWu1N+`vO}LWT$`z=;AWm2iXKFAk#YIIg#nI6S)>~B6 zaQ|`$*4iBp55_%BNHkELE@vi_F7dIdz!63LQDNp!dhw;bnShs4jubq2c*)3T0^vs~JO0tu({&}l0HmKdZ zrA?#Yp_Td;UZ}^!yzR(&gZXe}lt`WhTa8#(IV=(iIArOpEUQA*M#fQ>5wvD0jXZN` zB|%c+$LF)8QABDq)ydpwQRk0@>w${IdfYx+9oZked#?)j3~`;eg$m8tjQ1pp6dE_m z`i5d?MbDMlCY$9t#~q2Y6n=yKL21}_t6Ykfh&75>4C#n$U{VX0A6^>EXNTM8XS*4> z<$Sle+(*a%1CEEfRHKi_3#{4UL9jLz>97FcFZS3kHhOWnF_3sA#mfpyfp%^Gs9j!y zh^&zU@kWKs%wtrLcH1T~4)aIy5xm**rDB^YZ*VYfrbQ;^q-x}@H&uN;eV)L?vm(mP zmj4jdB2Pa|t>0G@r(4VX{}Fl_zhwFZI^W@oE@CP?G+9jN^F+^fG`yVaI?8RWE_}9U z4CFvGlMvAMSr0l`9$uif-gu5VA6GhC%CyZZ&?3)_VWUB^@+9LDJ`Ig~Jp)t%O&i|> z0(E}718^lE2>&eisPlX{$@cpYQ|c z(V!1rTwJ_Ta%_>HO$Z2lE9b4C;AWtAB(+~o7zHy~V|GI=4Pmz{0z_L7*gaasyMTKp z)$GLVOn!tcY}%dg`@Qe`KKJht??5y19CLY_R&0z+_aoPNGf4wR=FA-Dzu!lhNM8>n zt2^(sK>HlzO{AM6%s!V97Y1C}-omcC&|VLK02eh5sp%Sgp#w?mLU-|g#r)ozM@LeO zgoG4pCMk-G@GSPR6S(nq*UWy7R1u2qVmfY?FiYrz8VFIs@j(`$1;`?{q6mXpPXMF< z6xfZF8Xb6x!>S)){$-+y^ai5V61UE9-F%&QGCPZjrX?=w#SRJ$JPzs#Wqi!@L8r8A zHmd+ryXkxh#)c@3h%jrV%gJj9AdyUu#9gi|nHYbkFI$Y)f`m$?4ujm=(;SlMoVKCP z?KT+U-5)gD)bvGx$-ok9jucUeb*eJp54YSe?ZHe_?U*1JL!p3!5ti*%tmv;pnfbAu zM(*tPb@Ey6in1P$T<~&+VHUI60*&aW2VKU4mAcE+IK0mOEcbZAc>EF@pKs?4(*f|bst+|0B$@E zQ

3>L*`9VcwwcDW5VLi5wJUg@Z)jgJPzaD8i}-Q~hMD$;SFPD5ar@0vZ_zZ!E@| z@u5l_$PliZ9H=S$3%eDtX)kd#4}{0W`>xp}Dh;QzrR3+*F;z!s$vXCD)Pm0bTDm4Q zBre*pxz{ethztA#ZiD~+V(y+{pDF|eI z96b1|%InHJzI(NCtc*xZ1V+P1q7$#}#KvU2bF|@~qM5TX&Ea4Oc((g{CyDQ0LaD_P zJh;YVnKiq1mvMsuhvxD#_mz@;)0@o*5@J2}3Kc*x!3HQMU|^?&Yp1Kt*ZgnOlB9cq zIo4P?l5O3|Yas>*+wr|r5TbfgZMPy3U>Vc+yvf@?CAK>+{EgcVh(=)rFThFAjY_6q zsc=#x<5>VXTvCI`84olt_bjTl2Y^9Kdza>WrkPbehlX zJCQ^YdbwCe7;c63LnHAx%)8SA8~J!|0@`434E*<8=-lSg$A|8hr|Ne;zd|xW+>NJ& z<`$>CWuvJ)cx9h~B2H{0LCK9rs&T2N}5D zhkheMYQ%_P^|08n&sjPZ=ofA8F`E%PCGM2n-{&Y{Sm;+*FIoEw{AeP1GWH`H{NX4C ziuN=t!u<15m0AwB zW5>iC4-12#b@cMGvZ`a{`kIkhk?<`u-D=_35->fFqzmE}BHH4n)PDhF#Tvz|8R5J% zu8hY5T^1ti0ImZfoDBLfRBAH-N;*%wlpqEQKYS&cwGJN&#lm zsD&IjIJ=xo6dZ;J!TvLvcOQ>q+8j%`;ekLp&uPtZ=oP4rNk+4y@?U^ukniRSnn?lx z-?bC+?D<-4@o1E)D!|!M&Rmkx66->L0|aVl&SyV}FTJ=JcB=zbp#yeHHU6C6>4q2) zmYD6hEWVqIUhNh_p8dFVjr`g7li1v-T9c?Cx-%p+mSVzkN2kSMJDy;*ng8X=UzTvy z=aGW)y5xXg=p}}re|OOSeDD7Lz}~5cGl6moUbbCxs#oBCt?w-f+3|UztEg`_(=NIQ zJL*f|mJu{Ip(;rqHasTCG{{p2<385-!}I|v&>aBA3j+)?(->|U&!vq69Y=e2D8aag ztOV2LKj4FZvijRH(S>B{dv#Nn91K_}qR3-A3oMIKGrS?9qsRgL&m?n4OsUmgdkle9 zWP)NrHQJ;ta9A|9;3%m5j5|9!1N!V|zb@r7xUfk_q9NUzvQ6;^Ki{2&Oq~p+E}#kN zE;$J`txCZ7jS#`p`+bpZ9tf;#E)VoY`ct;_rSfJz%ssVMNQcE z_9aD@X0XIcwQ+Dx4FN)KR-#^0FfyRz|no zbZib(#-9+YYnA6&x*;EUxFkB1mDNqsad)UvD9{Qe${?t1_`X}+;MYVUW??8{{Y_^G zbrqY#!!gKAWP=nPNQB}D436oDAaa;yFTf3>kUg7&(-r1Nzr~oU&lv2>cATMa=q;q5 z>pAxlEg#mf7LKF>BQG{0)EwwA;7sMFr(ei7hzbj=V)^YhCS7yx%G}P!BPjBPE&$vT z8!8rE85^M>%W1B4QUMN3HuuZ?FX=jqy1d3gweX87eVqzgldB8u6t{l;swrHL_L1KpMkio_H z3Jy6w1Yz|%ouiH71(pyHMv|;dU7+B0Y_`a0x5k`7zxmuZNPTEIA6j;@Gx}CL^clWZ z@f>&5EB)Tmo>lDH!cD{(1d>&-NDgH=hE?5B!0|oVWcQb^z`B|@8E6a*DX{UHiV);-6ZFztrubFVbPL8{O2X9e1(DA~||Dd9EEh#D^6A z%%Ri`zPvavR~MH@zp6i+W!|5^t`q)83xH&pfo9TbD4o7r^pipnbY$osNl+AYf4tiB z%z6cIaMHL?XPh#yn*Iqmd=3d$j+^d75Gw~?hbg|hh-A7US|lUiy=fz^Uj9SwYSE=~ z0$sei-qhkRFLW4XS8#{qVCjHI-QGfTmr&KP8uX?d6e1b^Dvl8kIB{!%f?Hixu2Cmea`8Wb|2u! z2kkL^DsWD6Y7o>s#tX$lM|JT~0`oqH$O3n31n(Ds!N=)g_duKW$OXl)^_7Z|J6!if@^_8pd5TopVLa9F z0+kVsHOE%6!2z-RJ;c9!OV1U+ViFlsOiJg*DQ?_cQuNoF#0Xrgo{0g;peHVPa&z?8=yJ;2cS zLUg?=tpY+LCq#L{AG!BSLc0WK;wLDh-6PG1<)^&4@#c4P@-%brx1cT8;AXp(r-bu& zlk6|qXq;83I>^yH+o93*vjcqvpIu&uOb;DcEd>PfmgAPx_1k}SyUzVXaEI%V;dsb5T00mdKPzHn3_}S`*Ec-Q*Mw!f_6HcFO4G zj%ySmGyaIcd&9C%M?vx5I?fd;{(8#QfC5m&1tT(lhKb95`U;i|)|x36YusTfioKwD zt|2$276c#0tL~we81F9G&rjqnfe$AC+Z~DiwaiI=hj4H%ii3PQ7{RNYe9p#*$XKkP zR0ou_yimF|1vQbclH&wS zS;PGSCbOZ`XYc#=4FLL|qVL0tlMOg{8*V#M8eplXYpn^dP@;nnlUiR^D)S&`tbdG~ z;h|h|WVzRlkU$TI2Zm|TJ#A_?QGdujTaItdKF7_6-uvu1VS@3?b6Sk)Em5Mf5Si3J z!U|=HDOgy!diGMQqV?tW%0(BEj)d}lcNFq}adSu~`Xf)Fs_hz$`w>yq$t9zVh!IL5 zSZQK@$J{w8_?iPyT_XAVF(cjJF3|~zh)mj%fL-u!cB0GjWnSj=g7z`kBM5Orm-r-&p=+Z2>h)zrc&IvFbEjg#S^%2EL3}`SMc&W z$y<5~g9++R@zfxB-FN`fM4uk}SvRWa%x&6dkH`m-Ip3)N~t78NjKsx)Gq2{)7dUD%Y z_bN3(wF2{pLH>^seM6rYyh1aY2M5tpmF8td1{EQ{w{e7uSNQ+q@u!iX7X!N@=4|WL zMc+*J0t%zmy6rf^;;*CnZy4Q8znu0z>+)l~&7^cejXjt6KG6i{iXguO*y30H_gnoD zUNUlM*q#qC$6Tc{?aPqwi{x}rhq%Ubi0=a|qj5C(>SWA_R*|~JOkl38a zV+DVB_G$Ow$d9<=R>FznEI7&PGRzcM_#hP07H4Ig-ryS#K4Q!0TOm)ip<-9B+%(-}SBLeivObym4j4V{F{X%P}L&bvun6k-8znCAJ zas$5^7K#RkK$Dv)I5YH69b?2N!iXpc2bG;DH+k`6fL$^-Pm@0(dBkM6xnv?!jJ*I2 zJJ1|{Qp-XtIY)pgjy{x$U#UzkO44GbUcttEi8A!XA*_WDEguccu)>*M?yodsudqe4 zpffvXZ)SNOS2@p5Q>o&JasuNDI7y9x&FYgpw5d*u6T^#Y6x+tTUCXa+-eiKR`trvGTVIZ9$YT5IYS!nqC8e_{ zcSrv%`6&OdPwYj@yN8bH<4w+IlDDhAn3pUHRIRCD5J>1)++6RjYmX+|v!9ol4PL_RMjmAXsS6fTuN zD1@P;^y}NbUk(m*aFDcJLhU~Cq~HoHp1FSFOKtVXu1CbNkQdl4m*C)`c+d+=Dy?%u zQ;VysgyOkLL`1td@=F!S78wnkK^Qg<%p1ZT_U>{UFX<6W2LCMHESY0Ak*jQ&!^z-}7bQ}k zE?Uc2P@FXTNUBE1Xz%Yto9sR!+HpiQC4SXLbXg1QJx282&&tXJ$7Ake#R^1Of>4q7 z!g<8&+RWwy+KvmM%HZ~Ky8Y4R+}iyK@r9NeQOX_DO0h<$lIU>ZhBBA(w?B+? z(>XC0&S;m3Yw;WT%Gl_-NEYBdoQeo0>i9pnW0`MYoGiLQ^g<-o+{9G@Wj#i0fyt8EEkh67?sgA2bpC%knBJb0C!X}Fs z#oimZ4NGy4yf~Q%+gU-(_%tzaw@9Ktf(tENfJA4$P)cUiva@g!tAcZB`^{X0@Q091 zi)V!+_5Vm>EsB3s|EeRqOM(c6AQKfTo;97C)IK=Rlu{ENLcCtPU++j8J$er|1A`e3qt?5P;@7h zxODtDQW?dbR_j^Rt0oHoN=yVfJ)Z!t`l7{T?@yBV-mTi(x=|>b@N*H5l48yu!4ob=b|)0)@B7$+LUAa9jKEncet z-Q55r6+u{bL7T;Y=v=4i$Et*=a4WVUF%s1AwI%oQtP$HZJ5jE^W;u=Sq)q==z%krS zJ*e)Bzd~1EuMtiV7A(N{L$|^?8fx#xVq`A@}6#a9GX# z&{PvWqKWVU#|8o6IehhsF98Ey-8&T;0wKI0%`a%Fp25p3QLa7hjIydPg*j4BmE1G_;n@L6;0r3GkNA25X0#5mW&)=0)swn6oSaHuR@4-82%p*Z9NcqC4S zy#L2WS^M?v^4D59%527FNHiXRVB~|9vnt)zt2br1(u_+;;YN zg*Hc7!YRM!?yEuUt){V!B2LE&1JKv*IkdLpe@xOhc*i}+eQpI@hx55vwG{2BY z<|&iB#B?Tr1VLp6Zn41R9grUynglk$+S~tAZ0ptqsFl~_+#5j504PrV`c|ENIqK!f zBm2JylU4v>!qqo?pWr1`Mc0^Nwqyot#T`PbOh>Oi3J?<&6*;2|?$&W)2okw_Pjx);ky+rl~m$L?E2%KBuG+-zh$FuUw3kN8;V4K~wKis*N z#6QJ$J;$$_|Bn`+rv7WovoJYGgQCH|n_iTuhdbn+mzBuN0_)WhqDBH^!B|Wq4B>d2 zijgxmuy<;#of_aj;_$#0@s1lNO2LSRHxyUFSVT4&%A2W2_W1V?$|n^+q~E7mwW^i( zJC1Bq?Yn9xqe2uT^lk<_(`M8CL|{hG9Lb#Yt8mC3sW9an)FK>mRBTkCAHtAf!CQCj zjd;3WG-1G07m-AjLGczj4HeC?M_ITC4^$GQTr<}bD zSoH9{nSO_O-K^I8+;m3LhG1o5ZS!!C46Q$REcm<107dk#c9W~mma#G60*+JV>)U~? zQ$U8)G?DjimHtcLs@==zH?L#GiPxB4*>5@L4~?RNIc*O@c)sqd%!}&+wqAk-D0Epo z(a+D%xO|;+jf+v;pOo<1O)%|VL+0q1M^i%HzwH2f9u(sf3zt*htB%K28UDWpQS5+D z_kh3P-3Gzu)65Q3i^JN}u1Q%#?r3>VW>W_d-sn#ZPpQ;=<=~%WVzpwEEWn_%>CM%a zUm_?Du%9BMY_JYSzQ7ZVWm8wdiz1*+me3^@St2mz%Tm&Y0a23_s`w(1Wm{n!=P|T< z$`jEtPfC&HiWH_5Pm1X<`cp50i<&<-j7|zgIHQvV#P9G1?YzNq{`Eg&0Ys&Vd`6Vz ze;UWq4Hz%}&Wh;y+VrC`!4O#~zK z2MI>(UzEeme!86?EWU_#bVSl=NRqL1u*j|E_D#$sVhCB$3yZBA#A*B&vK7a<#a}-t z(Nb#LnNQFS(h~_Hg6UQFDv&762ac%2bn+9fcJxCD19FPkRRaF2!~$lY9bVt780M!r z-GjH0Mn%t_bCfE9jP@6#Wo+H-^gZ_<8FnPM!&KW%wadqVy%{(JkPt~cd-HL$>&~m*FO4KKiN#@EJmnc}b z2;|qaTQ=9k@gw`IsbtGRFm47x4lAI+iA5w8zRqE3X6g3{WDwH}p(;X<2@heWNHESq zWS@jnR%R($Nnx0S#v2>YQcNZxDheJ9&497nEsmZ##mU4`PT%GkXIV3hP(y4*S(tB2P2m5FrIEF{!(C?e?JD=yiuZ!~!-*#z3zs?ES_|qH%EAOU3O==wiQmdo*$h1{j z4aT6ro~mDqe#}+0q9F1t7P^%oBp9XkjfYLED7fn6KM3&R#|UOdXELeGsV_RTv<|>W z8GmMdJ-f4$Fwo_~o0#cgr~L{4#B<;*T%DP+618pt44W=FqA`o%X6TglESx#qsoyzR zHP3Jk4NEi3N878%_2fHbE9z1XtoUAb|6mTfh9@6VH6nwN&l}z3Lr1L8`;L(3gjbjI zcF~2l=ati(c9Pqw->8q#TN{w-Y}|0aw&HqU%Orf7^!w}nZZMRWr}Iv+a~gUNJb6AU z4Zn?i4^v^#8MpBud3Eb6yWF<7z7!2ykq|~;ZWQK9WsIk9q|umBd~?Y!-x^L9ZG2ZZ6}WNu@@d^3K>x)|_&5t4^M@&Z z{~p>9_398yhI>wPWjKR6&b~n6FG)DNOGH(&Tw@n2%85wal7|rd=D#p^5i1*{xWet>Cb8A|T7n^Eoc*1kevG)@9@w59_ z;_k)i)t!7v@g?Ea>;(X6ILz)^*wGekpVxee-4J@38j4Y2@&Jf8jp} za7w9$?fPop*Yw>o-LsC_c4N8iSLQ}nqmWL@W76&Q@b6!Mw`J9J<(vC!P@rUXYb?-+ zQB>TP=lhI=)Oq@a=^4muB3W?nrt zj8(l>tJQ3Ac6Rpi)oWtV>&siTIfmZ*V3@1o>7zy&D@V2ZZ-Hb-I|>WAnt@Mnw&n#x zGemd$ErOSl$tl>un3AF%N-7??Qn}1(#kf(W`4{>N@(G>^af)*F^y4$+GRIc3_2AoP zCjCw5A|b&f)*RL}sM-{ass6M@+|cFJym4H@6yRSms8M~GpvU$d1YL7Io&CPJG|sKa=Z~3$ zl3_|P4&L8!F&oFn~x14b|N^N{UEFOjuQd)aZGryWyZD$P5We35a+y z7TnRYvj`;#5?LER`)!w2_2ve&ON%T~lb>;jYJ^uZr0!7vmJ}%FHV;;O2B(Q4F2Odu z#2gh@=l(@9mw@f*QNjq@DJPz5SabcOSWc+}*4`c&<>%GkdjglOi-ss7m#veW+dDsj zgQ|D?fAenH*9$hWoe%dgG2G$n4J?ho;o5qgBV_;TWq7&fCV27N&wDW>vok~9^-Ty- z$`$f)Ge5n{hnIt6ubJNL9EI|`I{)Ha``CuUT#nCl{dCtO442( z)q%_A9}*`V7^na6_T8!t-pWd{;RS(};l|MLWH$oPZvi?j;Bp^or%wh`{Z!i&Odc{l zv-Ix2V1g)N!JzEh{k`*tHw5*&eQ}034Tf>_3uxFY&9@J?r()T*n_8F)~%nM{28* zw%37I3?9aQhZfbNlcO?qX+x424VP4-B`q@rjvI{!ke*F6OVG@KW>iEGCuN->2mN3@ z?|Sfdv;`Q}1tu4p3if5qW_Fm?8`RKFf9`TVGb@a`Wv~LG9lKalo$|q!y6ERwMZ(H3 zrt%2(cJ~zt@fClYy36_^lBjaYWC?NlzHVFHr}ply)A7 z%|E<-p9z~!HkhedHr>&>*VMdEqSHws(@;5qv)nKS@Y_muMof!evN(DJB$AbNwz0Hi zRrFQ&N<#>T5v(WF@{YI($0FVMX)a}(oFFw=Nlh3WhUyCA*{#PV*GkGF%svO`!j^a% z8v$T1Vs#cCEA9LqIJn@J_WOp)X-As!lu^`TjbI+{b7=ffcsKEYx~WUX8|!sodFxGB zAu6CPArqk5gP^k7|7zWpDqAGm#E(g4|6}5$bhUoJcX5)r^DvDqHT#O+tS^<%wfc4W z)#&w^$mi6>=rs`C?yXJ8{gUsUyLRgh=czsu$~5b>O8q-fk2}w*@;j9N5eZ%q0FHssGxBZ%`LT-e80iNgITL3G~<>RDZHf1gl->OG$kV_t=*E#uU zp6IJAm!F{_Ak%Zh>5UKe{nA>0-&(zdw@%L;uGZ_Gqi7;5s9d_W8+bRyd$ieWs^p9W#`{u+jQ)i!PPH0LWQx`{$7) z7|-|Qt#6qWb}; z0>L62pifA5=z(bms#5%OAkagIKai*2OU+TPIR_+`_Zf|Wh)|(^eNcvu1Ur)helqPB zJgNBFZT*Zd=4SsGpc2~}@;f&Ux5NS?pPvg*u=h=RCS)u~%aSSvbm1h@CFhsg!%A@r zBIuDr_%)+g7Ely_(821lSEk*%<7GNF>PLKDZ()B4rl~HJ>3c?`qs>SiJUvY(qZH}! z(m>b4iz(-Trjr&8RYesas^DG__rjjeAncUu^+MTadTw!y2ft0EnHt_1B?V=B%^Ze2K`Rrkk6aI0JBh<-XbZA~9x&GoBRejzft}g1f1Y zBOf3j+zsnZQ7YjJ0?MCy1B+RHv(vk?m9JR_Y#2z+iJ{_WNMPX~Z7Ix+w4XNC&WEk{ z>t2yLWBxfJ`Z94~pA3Qil~aP#-&tGK0{2tLX$fq9F{E)ilhJubHSr(vX7N@f!wgZL z?_qRjK=&j1BU{c-XQi`wlj-yL?e-j<&8eVEDR3n@x^|UkI&=AwVzW7I(BBdSl^K6oU#yn86uGjwwXZ#WspA8-UROm3& zAvgVx5UQ)9RApK@%gGsZV8#Iz0UzU;mn!>LcKT*Q4P+IqV%tD7miVRFsYlN`gt|J- zc&IyE+^~|`kr*2+S>`88*)L)^IizHSLxz|g)nQ!(r4qMhDD9hZ`ftT>(d;snsh#WV zL%0X3sYOBZVsK(3duUF^S>b66VVM4wh5`1AbnaiGYEuZu%2`Yi^Gd9$_70H|?{1NA zbmW&!U9C9n>ZOzhtV!4Q10xaNMJpT?!W8>TKkGF5Z>sX=d-U>gD^_zDWy*zzuZ~XMQiJOq@KV2HbJ_R?!{Q>rpS{xJU*V++4f47p zE_^P$_`d&}UX8^^D5wUWlvm8VhJbk|-{BDb;nyCyM>5}ebAe@@7v-z=<#o*gZ&`Do zSzMz1TQQbqVuiTfg&FWtmi_k80E7{G==mr>IBiKf5%SW~B( z_OK~TrD@&sq^a|^>LXWuztMGHW7`1jnodOv0fg_m*|Ps3T70;P?=R1MF!u8Wvb6X) zc9PO;HU)>r1+6AkE!-6iAA|vkCKEticAvi7+ys2x!hS|djr!n0AS%Xj_wY}1utULo zUm|}EOW_9itE-D+szNFL;OtGwo=d-%Nm#H3qBym~!!!?ZUFeBLI`v1nl5AF&)3)T% zk_qf=2do#xaxr|uO4^p3xZ^-ndJ|1mxoRNSvp$`iWFxpyI4YYEcm48nLOXS~Ino|6 z918mnq${m_4>y&(!XOIvta~IW32g*R=zOs+x*h$}hL#!lOUfccy@&XV?g!r5l7h)5 z5G26iT;pn*1Njr#=CuvsHK`) zC7K1-xs$-@)XcL<3C{B!@V{sEQK%HTUK-j%Mvzv7_-RTU1uP-;6zPzX%SA&AJVkGj z(eA=WK8vi^_&n9W6KD?{8lwU9&g+M;0LhhwHFL+8ObwINjQ)e#UTNVtsZ z0oOgm>yUw4E#PQWWBy^N%(F=qN?QGK`P18x7ER|LpIuGJkw7`E?CYypruV~OqPBkl z!0@q9tIKP-Y?4joVdiKkunXj2=}ERUUMcSo4!-vf?92G0d_ zjfcZ!(x_4v@ay-BYJ88{1fQxmJp1f^+8@JtxrE3|^O^ELpVogQ?k9sW5p34*-L3;gY6jn&GzhNF9fAwv`e|Hg$(Y1nfHgzDVEXU`;XT;)xn2KfcQn92 z=d0;_vaUuvGr0UHX$;{5cZC{y-)m^NKQ2-9yv%5wx!+cP|FaJ&^sLnu+2Tv!&P66 zzPZkE5fnX>n_vI@VvKflR)vUohy3{#8R_o+Mt%ABV(~H0Jg#sDE_1XkmSxm8z90G5 z9lsj4^vY z9Dgtd6@O&??Jm(M+`}SgfrflEeQEJ7iDD%PS~4D$tb1WGZ(|9Ate9&0!R+ zO+!(k=QRZ5*!uk5tB2qTi~lB9O(&lXuJ8v`6Hoh)-WdQYdf0PkvEVX={4<7RmImwM z&XUT3i*reZ1;?BM0%3%!Xcwg#tNr0g4Yw#)K*@J|v01>oEyLBu<_IafR0>C88O~C2 zEKMo=oa=Pln`S|lS!@Q<4QYGO3vnY@271Nt`OTs@P_x59W~7b3 zF#_QVKuhrQQKT~w`umm9BSp=+47ax$BVRIi^bzaNnLpt#?2C=XY8-n@GDYoUiXL?A zjAKiPx`)N_!X!z47NGQq^5!mQZF9FBOL3)8x`K6H^TS7-Dx&)7*Gu<)x_t4t{jsT; z-FR56$a&S9m)Popul#28e)u`(dAVfcDO!m4WT4BtA0U%Ngmyi5>7fhUti3x83UzhO zuL@Z>4^n>;i5jq130jM8Mj~$V2zQT4Vha@wW<$x|Bvd@#zgdmG&hZm`0+bs7crg4W ze2!u?h5sUWvh8@Xru8M3QRw-lel(et@%`$z(Ynvd8n9jV>{##o*73NXxlH|^JHle= z)|N@@62235NP1)|AUz|!E=)}P#&@@5=J0%25L>NI3%CV?H;{Xgp7&$Dcgap~bo+Q- zKkll5WA;e(M0_uo_TREtI1~+mCC^7N&7)TnyG0~p3b@8xTfS*Ug28!q0lq=95B1@+ zxF|0{p~$P7-@P0Ahwcy~46I-(FA_JqnvtLm)x8gI{Xe&4^fv`NPxKcX!|RN@)n~)C z{W9uL8$ij1k=WK%JBThX^mznq9yC=;YScG@pf27ls`gH?wm7WEU45MqgThlN>`s*i5x%5j?bU zxQti5riaWQH<~$r*|JzBB6QvBrjI#&K)Rfh3p>iQU_C+LmR=1~2)v<^WHCwk2bpk9 zu~Yax_Ya1F5Tv|8I2N^TQg6mlI$T8&Jv4R8-M%YAm7Qf=oFZ7JA@|fo6avg34=RFk z%CCL+qyxIHc-ppecxs6p#CfIW_)PqmBydYZSzMfI3hjlav+NEs1Mr#S7FE+(J= zP7g)Gto*c^JsE#xSjt6JK zdzdE4D|6mF;>-W2{Lv3~Z8P)z8?|o`!nn}e<6;6G1Gi18$UM8-cj^p7D=wWSR%Ph| zjDUSz$e4c}KNK*wzTo)X2pQg#wM{(E`tj~dXdzX>bse5145X}ddK~}}K;v;RRcki$3@6E?iMDJZ)uhCpNZ;^i9sgu25bE;p9f3CP;nZd01 zGB(CxG&)AJ9SGb+oc#49C2I;t@Oi(`6EkPU&qi;0wKEXV*t}CGq|V} zmZI`d9W$~^ibt4=a*z8YaTeMEK^i#O07z3+2{$Gr0Ik0w46-7h8SU?E0hsTm%qM+w zr=%JznO|5*%^_AS#6*pH!K?0Iq~w%2WKnhHw(LXdq^1H9YU`mf-j%4qm8G}6?k5^J zbR%tbWh!)G9M*FgGGta^=VST} zNskGXIZ*K(39TT8COO8W98Ei$aC>RMWui0hATAFa%{V=}XFa{ydXR91dU?@$=ZLW1 z7t7p1+(699$bY2T=n?nyvhj`p(T(aeukJ3HO?Ye$Rso~n19pRiIycXssUsSBqL`dr zsPTZSh02kF(=~brt*PklJT(80_;|_UNB`0ACLg=;`6latzXV{x^0}UBch%obrTkMM z;~eyO*yUL{M+7}pAdUruj#o>OMI=lBfQxkewI_Y%X zlM#Ad+3>m4%fZoGKuL2yr(P68uj1AkeRc31#Zv4|aafE5Lk#=(igtPYUoNDX*XqZ)U>nf%!}7 z!|6URmO@o?_4uMi`q78%PBa5vA_eP})*W@)o{lRHWc8VJ8!X=zTYWOz-u^Ek$<<@* zv9&ANuMO0&oiyjy%S&debzi)60cP8&uX6Vq`5|Y#O%~vj+F!mRy@Aoy3NVE+vMORV zOqEiNOO8-xb?|csg)i+L$o6sy{y^0rk`BU^BZisG7F>b>$FxVx?Lmo;(}~ytgmS0^ zP-sD~9a?i5Ea%{cq)RT04Z?`Wwf{gkaKaTR`LHeR##wF|D2Rc^;_VTr1>O(yVEQaf z=^)h47Js0j1>=IYeJB}SI)4BXQVKHUC8aBqFiW}`&Z|7`i%)P4SC(b8Cry&DH4$q3 zBD4uMd-%}GH}2F+V$-ytEv;|xG(nbilTS_It;*q@bBI0sD3YD<@i~ z)$G4PJEROe7|;AZEuyy@r<@6TF5hR#<3O>Bg-XvYI-`fLeve=O^Zw|nDNX#<>h3z{ zrs;i`*$FG70($jG=A1{9MT|m6RHnu_x z!HeZGk9g!X(_ahr(+cX4_2k0&v>94AP`5!I?)jt470b+*_eSo9AiQQJD{IqC>>dMDEYPJ*bv$ z$oD>3&>e^*&B_<~TWTu(=v3bSmsv_NtF+CTnXEgpca*8?1)yV@#Y@<782yXTYFPbH zvrlsGAZB12x|3woc&(i*(N5c<9vl_cWcl<9$NKO%4KHur78+Jzj_%x5cxTtSLM9T zO8MHa?Z!m+dj!Y--+0Gg%IoQVEH1|GKP*J3#h^9}Cyj%PX9|ig8Ma>4eYlg1iybJe*f&= zPd3h5cCuah7_!w6GQElc0t*rn5@Y&vS3e(sDfcoIZMvU|>IS;GZ9OraWwgk1l2TG9 zx1LhLt|U#I6T1sK9Wce9c~xU|l4YCmf<&N3w`E_X%5(awFUD&orFtjS7IKO35;9#a zp6y!>V>v)-ocSO%niK*Ft51r7hXvUp!EtANV}xO`6ib7WyNM8{=A-96OKmVWI~3O$ zJPK+=$B69*5>=)9&}Aeh2NU!v;;p~TtMX`oIcn~H2}1pp{A?1C$wz@kg!`?GT70Rq z@0}5B)t;j$Q&t*;cHB!QQ~-v@Udk5mlJ(UZ1@$;Ko<)-!wqx*-eUz1wtZxXTM~O+X zKODIc`WNb0Y2i9}GTK31I|3CylSpF2F1vpP@vb2=G%vy~L>ip6vxp$keEHuFDd`|k zIc@om+s!ZM{w1z4#)WFPyxo{zOY_Efj@ez-al%KorpWD!vma{5PNiMEI+o?x3I;^i zQIKvGXU6K0NWe%c8k)h+uOReF6y zQT}jUm%&U^Q9Ee|VP{DAz7Ja;=3j#kG}h6#3)4w<=Uo{Gj_x0#)dSzx>xwqZunC;* zuGDhcuF{!!wqN8l`Cm!(%1QBk9wr($n)j*R&)hnF_lCKGnSQ=aPD`C<_%P=2=!F%2 zAWVglBAJSjm~bs@MYKcUJ3F$w;#3Hdfjr`;a_^geQaO(MH1Z+=wH$ooSR1Ci@Om9= zX*eTAjz^W(6P|sU8<$4!+g+WTdraK6^Cr}`x=rEwq&WS4FVBAMXT>Y+_iRxOTrH5S z<~0p~%hGjtkkIQiip{C!Qycsm?5Px_yJ$~xB6@NO<~2@rdDigZMKZh%1BWDLg2w{T zxJ~7>TW_!aZ{84yX=M9Az@0t%p|^3{{lAexL*_G=10Uw{XK{H8>EK4rM7I0Y41cg6 zG3jJ|Nj%CLdGMw`{KeG^sOuc?C2AAw67<8ge=u~DYDLhK=3sA15yL^5>16ne5yP~j z_TYp`Sih~QXd$BJ{%C;j4RDpY1YLWKvf&=mO^67Ng0T$+;%PhTXda!ZP~4`UgpP!} zMM=d1A(-&tQUQDQLuCzbH2k4dz3%M%J5uJnyR@_c0n7bAdH#+mBXpR%9d7Q>scMYl zbf}n(<+K=6*|BDNj8fL!a^X#A8nO;Xv1er|qw}mQB5KyWWjyIOtb1eTl;~xdvTPR| z5Tf9nj*Aec7^x0RXqQYWI%0<**V%!z)TE@%5z?Y+-ncYJ3PgG=Grx+wNdyeu z<}0-N8p1*&ZN)9~nK^E?-%#L`8iD-8m%o)g*nd1ay&vlWO4c3T8T7utuLCRVr$glT z3$l&(MZFr2lcx8R`tJ{$a(<7Gv9=x8&_vldc`mTiLoulBI9WTXc88vIv-M1#oO13r zJyLdEd#-6vC1#5JfEvfEAGi@STDzYrMJc=-J`wpmb@@CU#~S(osS9e-C~uK4g0Ya# zc+9sq01W}qm+Vgu)cu!A{tHm*&Cml%k0%u=0x0H{5_SZt0}(RLQiRvwKh+)IAzF<8~WjZIe z5I|vSBT5OQfLfc!%rG_ab;5zml#F5^45|vQc*<&?dpBZRz?eAh0l&@tk8dmS-4

zFw~uT8Y;}Lv>Llr=`?(Eh3bN8VFN;Mf0oHI*qB8Mh0d=(t=b5N+x0V3mj%K!zdvb0 z$a~h9fY3vl)(kzQ;+WZq8&IG)x+_;1Dbr}3v1_KlTH&0u%}876lCSE%0H`D*R_;}< z=F*zKM%75_UQb@zj_R~PtsXrmh7%WEhco*rV>XGusuaYrkU1n3&m_@l>%+rZ=!1#v zqn(gTCYl@yZDl{m_f>-@u~cq=wXjL|_$)kMn$%{7y=vY@NA`E}UWf||r4!>QYb&?4 z#ODdQ#6O^LQZ<@XM3P(igc^B5x}XBfhP0`h-f5Xxa)e-FR50WfTT?;eL2vkSdO3vr zMXwS`p0KT0P+tqF_}>Dq*TJ)#*C}HorD?g2bC`G6_r>bY z6Qj57-!>Z#D?**u(?o_^8!b4GBytil4wkW9-cCcjU0Q=NLVFKpN{H{vU_;+(MxG0Q zna)QXblp7K`Mm2fwO!S*P4ECyWr_3V+n7n;r+T92>sX(iR=Y|s%QZoqRjMzpm%yZq z00+lpUE;sjPh(3<>QPq0ECC=+k(j9T;%CUaGYejzpE2mklzr6V0wup39jZS?? zN6$==+}A8GgcWFS|zNoy*SX0XT+?uG+rw^Dlc2QEa!km{2RvgwA2 zz&L=WjdPOki?sbY+3wW9I@op(j#CQ1PeC6n3*qhnfJ zK-Pt-bsa^`rqSis1E1*Wib~O>;&oH~Q*?4vRC;*wsA~fFNib??0$xr@1=DWkRL9gU1!G$I z8u0vmV!*tJ(V}WR=PQ=JvZW>M&>20-W;oz)IL|6b>;5s!QkXfpnnC-WMiCiOa{hF8 z>-R6Brt|iN?|sq>36I_^Z~nQ^ECO*!jbqTg2Z3=jZ1sKg`J!cqFl|uD=hbJ@bG_d8 zLdo}H{KEU%iP2N>U!(}~+WS=M`|T)^?{lb--`T-MXUBEys^DAMS3SVv^07C*I0S?W z2zdU$N+CKn_PW&lPUk*IE+jNmrtJG_^S>Cr^M~b0Ustz}yzCTe^GS8v_s++CAd8bcH zAeUUVXJuA*TzkL;QrO>M@H1p7M@eDX&#GJDmX*~6s?JeKq8<1<$?ThG+wcE$!Wl}2 zDvj_LhrpPyq1ks3yk#6`y>Rm1Wu~Z+fD)w}t+S9^XBA5S*-Ox2U#hoVp4#48r-+1sc`BcG9240JOA%pdbYM z^);a*;ndGbj1(3E7W&6_;Q2Vx7&9%B2>+B3hrU65!~3s1>mt?k>E~VRm~+_oo{&aYV`_8# z9Q}!lczXaHsUB<;cbhljg86Wr6NG4zzLCCmz{mN*KWqki<3BwSKK~0y>Gfr^ z=#u)4Oz%3I{o4Gae5oLmflHL>7=LE!(+h%rrLfPQYti@ zfv?H^kuZQ1?fJQ)W8Seyl~!xS0l!}bW3Y(39m1ZzpMn}zmIY?$?+}O-6>heIVram4 zM%yecAzZx}8RtcRw?xDHQeQk-gtg$o0Lq|My~IU((pgCxnITUsnbuNfJ%51Z2+#)r z=cqX;bKQSX*ceBwX@gRsQ-@!Lgn(+Sfl${;&okkwUDN*-qI~biKT|umX3!M{!1;*9 zF1OxaR^A_nyIywP0FT1A%q9~4A@Saq(t;S%d)q1sBEjj8^UD%)iSGXHF2O*j#qmp{ zuE0>qz5eX&{r#-V`|Ev)75psl@geksj1f9JU3?X~@cvifcac8nvvuuv?Naj^*!1)M zCG~eE0RaIN`<3_rXqM5B|7C}DR~(-7pb!fmLs^^={Ab+Qzg%KY;McL$sS4sS*U`f` z9{@iK`&95i+JbR+I#F>w5I9k3a&g{)T3e2C8C=zc{DjniDOIdXlPXuM0VgbeDIKLE zf=vEH$-Ye*lZ`eXey3_$8uJg@kR^RTx#^b-(&V9M>GtF}V)l_2O4U((%2{f);Y;Cp z(5U()Ed*jjboAUGXbm%RqNDzZ9H)S3Ww9p8)qWH>l+a&7!vrtvFLCe=QA z>nq%YlHtuP1FaJPF4K=1$7{(Z_}s`-_p-54pY({u7WQS-#DP! z+cq4D8wL78)4o%%^BG2hBDI!Wu7>0*s2H_)Vq@Afs@Mf}is9ktG6HK~R3KIhma9a$ zT4$^xLPH`qA{5x+KtVeI*3Lu8&A2e(8F|V9D*G?UVJaGOMXD|OjN`O>jxZ#;dyZdu z4C>4Dvr}2MBww<8pv1T{CwMO^G3m63yS7%ilrQKQ41Yg(FnO&a?$ zG0MmDmGieIzn3QDuGc=Jw?!r)_lviJDIb?&gB;>Y0E?6n_3(kj17e>51<7Q`pVpwQ zD<4%G5P7cw%l4D1rfR*W?||}gSNpG0FICXjgZlsG@*jxDeE&}zp9A&fr@69 zK~&K1Jj)+q*&Usu>S_h#BtJQFv5}plY^RK^g;l>3N)hh}FjJxgW_`+|L7d>#N8AOo zl>xJy_;MKOmi>qDIRO%s+=@sLOK%iwT{#f&^`}F+%S5R*i)Q{%B>aQwe0j=T(w|%_ z`z5{?7E+Hw{G|aN?2P>Q=qOWhR;IFR91DSdg)V++B^_1bb&co*;r=PcnQr2pHQeah z{a}LxW+UdUODPTY@D9{qWB;cf7}DzaG-*;SGyb0>!~j`Fzbcy|T}cfyd~N`GQ)?uT zNYu9XM?i^(4$z816jNLFlciYkjM%luX z+Qo^Zb+=#j2^%Veh3n;04v4SYqWKu1b41$x5q~d*3&(Ze>W7NXAV&QhNlc9R+>Ka& zA$MUg+HvqA)O2oNR>nK8HgB+|w&rur?{wUaphX&eB5nI|V^<=r^0dZNm6ndV$ zBsJACj9C$o3HhOPq10Y~YB1cupx@QQM5>#lv;&S3Gqe@bPzinBz8wnH+Y!wB3MSw= zHeuSV{?^v%wdf}FI+*kJm%+&EszhmqoV8e-2@9nVBm&a|N8wrfgP5hauIDtUchC5u z_q$-`c=ps14v@Mx*?i&Zd^~>tx4!Xm`QCcRCFFd>)KOK>r+=r?M02Y362%PpW_MRdTmYX7N+ zJR)(xWE05A0w5ecD(39$M<48$CZh&U{W{0-kn0U){YJYD!Sj%QX$k?|NtNM|!6;VV zXt}$yk?W!CaAm$Xq0gldVzuyir)Ira`oDVa$^8>ml2oNtxRa8?;z;R%4tT&ls8=RT z7L1&KrzGztp~jn__ixc$1qEwn zqZ%4!wlDB_Q(-6wFpAQap{aWON%v>>pM%~a^~}EHPnVxohaN=w7E~<3nl4?8Hf%2H zVX~+yn^zdOWmjebmcgvNDSX%snt1KLWFoGfNX+_7;7Mv6G&To<9`~z^l)ylu;DMK% zn`Rr(#xAGD1gT;svulx>YowbM1?7r1VnCQgL7^@LcA^$tl2FS9QBuH`WFP1_2$wTc zW1(D{lF#(SOUKHgMA4X$s|v?`{I-Gx`v31YL^cMM09^bR;H_HuBN>h3&mO>xHqh4% zn>B?B9mT8*Ns$ogd!C>DxD{LQvgr4s#X>l*%8ET=%CnQjwtk0a_ng@Elvq*I=GlLY z3A!OV>UxK{_j^;zdEegf{kKIVz|YE$wz7l%X#^CGfkHmBgI0)ZwjZ$kFf%{jAM+?Y zz44B};oIA28`*N>;N+ZY7QUROAnSI~Yva2USkrPj(@84lgfJTqLlv0qc1>CrUwce2=wZE9u}l|aI${gYF#f) zmWeiESP0JD{#=dNRCaheB0Slf9Z2WiUd~5M78Osa&=vc;Q`kJXWK|5#O_M4S4%Ij* zQd-z&ak}>9LgTOBlh{=yNrID3cXqycvZg1gdXA{c(u!0bviOVQoxwfzN5iejvPMhN zY?)y3=Ewgl+?J5V#ElRwC@q9Si;;%(1uOAYruGp!IACkh=S&@iIrLqiO2G(eM#FY4 zc-0rooILO@aOloOcm4_r=?&jtYohl z6SpK`_Yn6cp>9A8n4Zmso`H4zP91;Ps{&FyWJTFMM3W6SXWdGqobz8OW^N&#^5-mM z3CC72F1+C{;}`sfUS_T)XA=OkNnMtNBFQ4C1Q${rbt6uiCr!#(#2>3xzymR!8-3uR zpfEl@ezd=j!4CUNm`&O~gIqcrt;I_f1@pLj@h@@!{x(cH|0=XUjXk_qfTS$EWFdxw z1#i5(S42D2AG!X@C>HSdVBrHHYjRP0I58IavCWA?Vr3}O7Iuj2nD8)U{wYlx1)M-_ z+`cUDkzbQTnMfda^1lxf1Bz7<;8+-3v}pAF54(L6!|cqz9QR}$byhW71x4=QIlxzl_+TDmI z!+$XE&&bv9RVQ3oZT`pI$l30@;WgfGbUBaLldDem0?)1&pKKvzC=-AF{5gAF#V=@` zAMMEQ0DK4BEtjscz0T8@mJHvED-Hl+MPZftasFt{c}5fQfK$sVkYaz}kBUFidf>(- zMCuX}@?8u?B4`Cnj;dR$bm6XCqoVY6p{cX~3^UZW z>%4gfDb77+myM_6qVpLRl|`7)_rZjd^MRck@e?Q<`6>(hFxUD1Y>c1U~h5cMLQ=9>zVS^x#ykBZ@wzpZhfbu*Tc>zAB+Z z*pngJ1!p-3nd8;;^#!%PcHeWLS@vQ%RCZnlm^7O(fvmqRRfeL0s)~qz&m}FMH1%(-Q2POn02CDj`fG1=J5#_Tnc@Q2OK|bYSQ3-4B46+W{?~R)c%=AWi(6!;s z6;_S{U)(Z@S`f7vL4kKh3E~Jqkqzs`As2=U{5pa2X0{3Ai}HZ~Xb*as6v1bp?&~aK z4wHop86|eG10^tbB2y`|r;J7)5!=1A!$UyaJNJ^sAzBUS2Z=Z`A_ST}$}{FHc2360 z=kf&fZas@A+WdLYedfKyX=C9<`{rHl1fB)uKaC4V-4doMyNZ6BpJ~tUtc{{9j&c)R zQf!Y=%oGj$Q$aRDO>Htvp+s4cn*?gT1s)C|K5GdZ_89pW6h9#N3)|qEZWek%FEumi z)R{XwJ1pTr0k01x531B(DKZ^W$Y()L|A>}|xvjo^ zgR(V0IzQiUwXAxyry)G(w`*;#>iBG*)zz~kP=i;0zxL4S_WIVw*nZP{7jwyF-F~ww zxAF3q>wSBm>tR5v%ir*{9`(kVSAdy$^La(I-jy<_2 zd%efCMYg=dvAHBOiqUJrwBzk0|Mgg` UIMs00vDJST@zM(y3kLzvFZufVFqbll- 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 OVKUG)##iC&L;nlI@Q&dC literal 0 HcmV?d00001 diff --git a/workflow/workflow_mat_anyone_v2.json b/workflow/workflow_mat_anyone_v2.json new file mode 100644 index 0000000..876b56c --- /dev/null +++ b/workflow/workflow_mat_anyone_v2.json @@ -0,0 +1,1364 @@ +{ + "id": "b93b71a0-0eab-4079-9e10-83b529e72423", + "revision": 0, + "last_node_id": 51, + "last_link_id": 103, + "nodes": [ + { + "id": 42, + "type": "VHS_VideoCombine", + "pos": [ + 66.40084289550799, + 667.9227734374999 + ], + "size": [ + 315, + 513.9375 + ], + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "localized_name": "images", + "name": "images", + "type": "IMAGE", + "link": 91 + }, + { + "localized_name": "audio", + "name": "audio", + "shape": 7, + "type": "AUDIO", + "link": null + }, + { + "localized_name": "meta_batch", + "name": "meta_batch", + "shape": 7, + "type": "VHS_BatchManager", + "link": null + }, + { + "localized_name": "vae", + "name": "vae", + "shape": 7, + "type": "VAE", + "link": null + }, + { + "localized_name": "frame_rate", + "name": "frame_rate", + "type": "FLOAT", + "widget": { + "name": "frame_rate" + }, + "link": 102 + }, + { + "localized_name": "loop_count", + "name": "loop_count", + "type": "INT", + "widget": { + "name": "loop_count" + }, + "link": null + }, + { + "localized_name": "filename_prefix", + "name": "filename_prefix", + "type": "STRING", + "widget": { + "name": "filename_prefix" + }, + "link": null + }, + { + "localized_name": "format", + "name": "format", + "type": "COMBO", + "widget": { + "name": "format" + }, + "link": null + }, + { + "localized_name": "pingpong", + "name": "pingpong", + "type": "BOOLEAN", + "widget": { + "name": "pingpong" + }, + "link": null + }, + { + "localized_name": "save_output", + "name": "save_output", + "type": "BOOLEAN", + "widget": { + "name": "save_output" + }, + "link": null + }, + { + "name": "pix_fmt", + "type": [ + "yuv420p", + "p010le" + ], + "widget": { + "name": "pix_fmt" + }, + "link": null + }, + { + "name": "bitrate", + "type": "INT", + "widget": { + "name": "bitrate" + }, + "link": null + }, + { + "name": "megabit", + "type": "BOOLEAN", + "widget": { + "name": "megabit" + }, + "link": null + }, + { + "name": "save_metadata", + "type": "BOOLEAN", + "widget": { + "name": "save_metadata" + }, + "link": null + } + ], + "outputs": [ + { + "localized_name": "Filenames", + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null + } + ], + "properties": { + "cnr_id": "comfyui-videohelpersuite", + "ver": "5e61bcf218fe3bb7c899bbd584bbc99a9d05fb42", + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "GB", + "format": "video/nvenc_h264-mp4", + "pix_fmt": "yuv420p", + "bitrate": 10, + "megabit": true, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "GB_00001.mp4", + "subfolder": "", + "type": "temp", + "format": "video/nvenc_h264-mp4", + "frame_rate": 30, + "workflow": "GB_00001.png", + "fullpath": "J:\\REAI\\ComfyUI_windows_portable_nvidia_cu128\\ComfyUI_windows_portable\\ComfyUI\\temp\\GB_00001.mp4" + }, + "muted": false + } + } + }, + { + "id": 47, + "type": "Reroute", + "pos": [ + 491.8094624515745, + 420.8710519552324 + ], + "size": [ + 75, + 26 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "", + "type": "*", + "link": 90 + } + ], + "outputs": [ + { + "name": "", + "type": "IMAGE", + "links": [ + 91 + ] + } + ], + "properties": { + "showOutputText": false, + "horizontal": false + } + }, + { + "id": 2, + "type": "VHS_LoadVideo", + "pos": [ + -856.5314306640627, + 408.2031335449222 + ], + "size": [ + 352.79998779296875, + 511.1687149392035 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "localized_name": "meta_batch", + "name": "meta_batch", + "shape": 7, + "type": "VHS_BatchManager", + "link": null + }, + { + "localized_name": "vae", + "name": "vae", + "shape": 7, + "type": "VAE", + "link": null + }, + { + "localized_name": "video", + "name": "video", + "type": "COMBO", + "widget": { + "name": "video" + }, + "link": null + }, + { + "localized_name": "force_rate", + "name": "force_rate", + "type": "FLOAT", + "widget": { + "name": "force_rate" + }, + "link": null + }, + { + "localized_name": "custom_width", + "name": "custom_width", + "type": "INT", + "widget": { + "name": "custom_width" + }, + "link": null + }, + { + "localized_name": "custom_height", + "name": "custom_height", + "type": "INT", + "widget": { + "name": "custom_height" + }, + "link": null + }, + { + "localized_name": "frame_load_cap", + "name": "frame_load_cap", + "type": "INT", + "widget": { + "name": "frame_load_cap" + }, + "link": null + }, + { + "localized_name": "skip_first_frames", + "name": "skip_first_frames", + "type": "INT", + "widget": { + "name": "skip_first_frames" + }, + "link": null + }, + { + "localized_name": "select_every_nth", + "name": "select_every_nth", + "type": "INT", + "widget": { + "name": "select_every_nth" + }, + "link": null + }, + { + "localized_name": "format", + "name": "format", + "shape": 7, + "type": "COMBO", + "widget": { + "name": "format" + }, + "link": null + } + ], + "outputs": [ + { + "localized_name": "IMAGE", + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 41, + 92 + ] + }, + { + "localized_name": "frame_count", + "name": "frame_count", + "type": "INT", + "links": null + }, + { + "localized_name": "audio", + "name": "audio", + "type": "AUDIO", + "links": null + }, + { + "localized_name": "video_info", + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": [ + 71 + ] + } + ], + "properties": { + "cnr_id": "comfyui-videohelpersuite", + "ver": "5e61bcf218fe3bb7c899bbd584bbc99a9d05fb42", + "Node name for S&R": "VHS_LoadVideo" + }, + "widgets_values": { + "video": "test-sample1.mp4", + "force_rate": 0, + "custom_width": 0, + "custom_height": 0, + "frame_load_cap": 0, + "skip_first_frames": 0, + "select_every_nth": 1, + "format": "None", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "frame_load_cap": 0, + "skip_first_frames": 0, + "force_rate": 0, + "filename": "test-sample1.mp4", + "type": "input", + "format": "video/mp4", + "select_every_nth": 1 + }, + "muted": false + } + } + }, + { + "id": 48, + "type": "Reroute", + "pos": [ + -379.6686904316001, + 257.9196253900885 + ], + "size": [ + 75, + 26 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "", + "type": "*", + "link": 92 + } + ], + "outputs": [ + { + "name": "", + "type": "IMAGE", + "links": [ + 93, + 94 + ] + } + ], + "properties": { + "showOutputText": false, + "horizontal": false + } + }, + { + "id": 49, + "type": "Reroute", + "pos": [ + -98.94869043160021, + 856.869625390089 + ], + "size": [ + 75, + 26 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "", + "type": "*", + "link": 95 + } + ], + "outputs": [ + { + "name": "", + "type": "IMAGE", + "links": [ + 96, + 97 + ] + } + ], + "properties": { + "showOutputText": false, + "horizontal": false + } + }, + { + "id": 50, + "type": "Reroute", + "pos": [ + -98.94869043160007, + 813.3096253900883 + ], + "size": [ + 75, + 26 + ], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "", + "type": "*", + "link": 98 + } + ], + "outputs": [ + { + "name": "", + "type": "IMAGE", + "links": [ + 99, + 100 + ] + } + ], + "properties": { + "showOutputText": false, + "horizontal": false + } + }, + { + "id": 40, + "type": "VHS_VideoInfoLoaded", + "pos": [ + -426.499259643554, + 358.92265869140675 + ], + "size": [ + 250.4166717529297, + 106 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "localized_name": "video_info", + "name": "video_info", + "type": "VHS_VIDEOINFO", + "link": 71 + } + ], + "outputs": [ + { + "localized_name": "fps🟦", + "name": "fps🟦", + "type": "FLOAT", + "links": [ + 101 + ] + }, + { + "localized_name": "frame_count🟦", + "name": "frame_count🟦", + "type": "INT", + "links": [] + }, + { + "localized_name": "duration🟦", + "name": "duration🟦", + "type": "FLOAT", + "links": null + }, + { + "localized_name": "width🟦", + "name": "width🟦", + "type": "INT", + "links": [ + 65 + ] + }, + { + "localized_name": "height🟦", + "name": "height🟦", + "type": "INT", + "links": [ + 66 + ] + } + ], + "properties": { + "cnr_id": "comfyui-videohelpersuite", + "ver": "5e61bcf218fe3bb7c899bbd584bbc99a9d05fb42", + "Node name for S&R": "VHS_VideoInfoLoaded" + }, + "widgets_values": {} + }, + { + "id": 51, + "type": "Reroute", + "pos": [ + -98.9486904316001, + 900.4296253900897 + ], + "size": [ + 75, + 26 + ], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "", + "type": "*", + "widget": { + "name": "value" + }, + "link": 101 + } + ], + "outputs": [ + { + "name": "", + "type": "FLOAT", + "links": [ + 102, + 103 + ] + } + ], + "properties": { + "showOutputText": false, + "horizontal": false + } + }, + { + "id": 15, + "type": "MatAnyone", + "pos": [ + 74.78596496582053, + 474.3490966796875 + ], + "size": [ + 236.8000030517578, + 142 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "localized_name": "src_video", + "name": "src_video", + "type": "IMAGE", + "link": 94 + }, + { + "localized_name": "foreground_mask", + "name": "foreground_mask", + "shape": 7, + "type": "IMAGE", + "link": 100 + }, + { + "localized_name": "foreground_MASK", + "name": "foreground_MASK", + "shape": 7, + "type": "MASK", + "link": null + }, + { + "localized_name": "solid_color", + "name": "solid_color", + "shape": 7, + "type": "IMAGE", + "link": 97 + }, + { + "localized_name": "mask_frame", + "name": "mask_frame", + "type": "INT", + "widget": { + "name": "mask_frame" + }, + "link": null + }, + { + "localized_name": "n_warmup", + "name": "n_warmup", + "type": "INT", + "widget": { + "name": "n_warmup" + }, + "link": null + } + ], + "outputs": [ + { + "localized_name": "matte", + "name": "matte", + "type": "IMAGE", + "links": [ + 36 + ] + }, + { + "localized_name": "green_screen", + "name": "green_screen", + "type": "IMAGE", + "links": [] + } + ], + "properties": { + "cnr_id": "matanyone", + "ver": "5d2c4294dbecc0f117d994a6545fa7db7cbe256f", + "Node name for S&R": "MatAnyone", + "aux_id": "FuouM/ComfyUI-MatAnyone" + }, + "widgets_values": [ + 19, + 10 + ] + }, + { + "id": 45, + "type": "MatAnyone2", + "pos": [ + 79.7358042483442, + 240.60861919516236 + ], + "size": [ + 285.5999984741211, + 190 + ], + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "localized_name": "src_video", + "name": "src_video", + "type": "IMAGE", + "link": 93 + }, + { + "localized_name": "foreground_mask", + "name": "foreground_mask", + "shape": 7, + "type": "IMAGE", + "link": 99 + }, + { + "localized_name": "foreground_MASK", + "name": "foreground_MASK", + "shape": 7, + "type": "MASK", + "link": null + }, + { + "localized_name": "solid_color", + "name": "solid_color", + "shape": 7, + "type": "IMAGE", + "link": 96 + }, + { + "localized_name": "mask_frame", + "name": "mask_frame", + "type": "INT", + "widget": { + "name": "mask_frame" + }, + "link": null + }, + { + "localized_name": "n_warmup", + "name": "n_warmup", + "type": "INT", + "widget": { + "name": "n_warmup" + }, + "link": null + }, + { + "localized_name": "r_erode", + "name": "r_erode", + "shape": 7, + "type": "INT", + "widget": { + "name": "r_erode" + }, + "link": null + }, + { + "localized_name": "r_dilate", + "name": "r_dilate", + "shape": 7, + "type": "INT", + "widget": { + "name": "r_dilate" + }, + "link": null + } + ], + "outputs": [ + { + "localized_name": "matte", + "name": "matte", + "type": "IMAGE", + "links": [ + 88 + ] + }, + { + "localized_name": "green_screen", + "name": "green_screen", + "type": "IMAGE", + "links": [ + 90 + ] + } + ], + "properties": { + "cnr_id": "matanyone", + "ver": "15fe8a622223dea4eaa65a8828937544b0bfbd41", + "Node name for S&R": "MatAnyone2" + }, + "widgets_values": [ + 19, + 10, + 0, + 0 + ] + }, + { + "id": 46, + "type": "Reroute", + "pos": [ + 491.80946245157384, + 381.1610519552331 + ], + "size": [ + 75, + 26 + ], + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "", + "type": "*", + "link": 88 + } + ], + "outputs": [ + { + "name": "", + "type": "IMAGE", + "links": [ + 89 + ] + } + ], + "properties": { + "showOutputText": false, + "horizontal": false + } + }, + { + "id": 5, + "type": "VHS_VideoCombine", + "pos": [ + 407.07914184570353, + 664.3545971679687 + ], + "size": [ + 315, + 513.9375 + ], + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "localized_name": "images", + "name": "images", + "type": "IMAGE", + "link": 89 + }, + { + "localized_name": "audio", + "name": "audio", + "shape": 7, + "type": "AUDIO", + "link": null + }, + { + "localized_name": "meta_batch", + "name": "meta_batch", + "shape": 7, + "type": "VHS_BatchManager", + "link": null + }, + { + "localized_name": "vae", + "name": "vae", + "shape": 7, + "type": "VAE", + "link": null + }, + { + "localized_name": "frame_rate", + "name": "frame_rate", + "type": "FLOAT", + "widget": { + "name": "frame_rate" + }, + "link": 103 + }, + { + "localized_name": "loop_count", + "name": "loop_count", + "type": "INT", + "widget": { + "name": "loop_count" + }, + "link": null + }, + { + "localized_name": "filename_prefix", + "name": "filename_prefix", + "type": "STRING", + "widget": { + "name": "filename_prefix" + }, + "link": null + }, + { + "localized_name": "format", + "name": "format", + "type": "COMBO", + "widget": { + "name": "format" + }, + "link": null + }, + { + "localized_name": "pingpong", + "name": "pingpong", + "type": "BOOLEAN", + "widget": { + "name": "pingpong" + }, + "link": null + }, + { + "localized_name": "save_output", + "name": "save_output", + "type": "BOOLEAN", + "widget": { + "name": "save_output" + }, + "link": null + }, + { + "name": "pix_fmt", + "type": [ + "yuv420p", + "p010le" + ], + "widget": { + "name": "pix_fmt" + }, + "link": null + }, + { + "name": "bitrate", + "type": "INT", + "widget": { + "name": "bitrate" + }, + "link": null + }, + { + "name": "megabit", + "type": "BOOLEAN", + "widget": { + "name": "megabit" + }, + "link": null + }, + { + "name": "save_metadata", + "type": "BOOLEAN", + "widget": { + "name": "save_metadata" + }, + "link": null + } + ], + "outputs": [ + { + "localized_name": "Filenames", + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null + } + ], + "properties": { + "cnr_id": "comfyui-videohelpersuite", + "ver": "5e61bcf218fe3bb7c899bbd584bbc99a9d05fb42", + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "Matte", + "format": "video/nvenc_h264-mp4", + "pix_fmt": "yuv420p", + "bitrate": 10, + "megabit": true, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "Matte_00001.mp4", + "subfolder": "", + "type": "temp", + "format": "video/nvenc_h264-mp4", + "frame_rate": 30, + "workflow": "Matte_00001.png", + "fullpath": "J:\\REAI\\ComfyUI_windows_portable_nvidia_cu128\\ComfyUI_windows_portable\\ComfyUI\\temp\\Matte_00001.mp4" + }, + "muted": false + } + } + }, + { + "id": 3, + "type": "LoadImage", + "pos": [ + -497.34781982421777, + 512.7826000976554 + ], + "size": [ + 315, + 314.0000305175781 + ], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [ + { + "localized_name": "image", + "name": "image", + "type": "COMBO", + "widget": { + "name": "image" + }, + "link": null + }, + { + "localized_name": "choose file to upload", + "name": "upload", + "type": "IMAGEUPLOAD", + "widget": { + "name": "upload" + }, + "link": null + } + ], + "outputs": [ + { + "localized_name": "IMAGE", + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 9, + 98 + ] + }, + { + "localized_name": "MASK", + "name": "MASK", + "type": "MASK", + "links": null + } + ], + "properties": { + "cnr_id": "comfy-core", + "ver": "0.3.25", + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "joker_00019.png", + "image" + ] + }, + { + "id": 39, + "type": "SolidColorBatched", + "pos": [ + -397.20913696289057, + 877.9945092773443 + ], + "size": [ + 210, + 198 + ], + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "localized_name": "batch_size", + "name": "batch_size", + "type": "INT", + "widget": { + "name": "batch_size" + }, + "link": null + }, + { + "localized_name": "height", + "name": "height", + "type": "INT", + "widget": { + "name": "height" + }, + "link": 66 + }, + { + "localized_name": "width", + "name": "width", + "type": "INT", + "widget": { + "name": "width" + }, + "link": 65 + }, + { + "localized_name": "red", + "name": "red", + "type": "INT", + "widget": { + "name": "red" + }, + "link": null + }, + { + "localized_name": "green", + "name": "green", + "type": "INT", + "widget": { + "name": "green" + }, + "link": null + }, + { + "localized_name": "blue", + "name": "blue", + "type": "INT", + "widget": { + "name": "blue" + }, + "link": null + } + ], + "outputs": [ + { + "localized_name": "solid", + "name": "solid", + "type": "IMAGE", + "links": [ + 95 + ] + } + ], + "properties": { + "cnr_id": "matanyone", + "ver": "5d2c4294dbecc0f117d994a6545fa7db7cbe256f", + "Node name for S&R": "SolidColorBatched", + "aux_id": "FuouM/ComfyUI-MatAnyone" + }, + "widgets_values": [ + 1, + 720, + 1280, + 0, + 255, + 0 + ] + } + ], + "links": [ + [ + 19, + 7, + 0, + 5, + 4, + "FLOAT" + ], + [ + 49, + 7, + 0, + 33, + 4, + "FLOAT" + ], + [ + 65, + 40, + 3, + 39, + 2, + "INT" + ], + [ + 66, + 40, + 4, + 39, + 1, + "INT" + ], + [ + 71, + 2, + 3, + 40, + 0, + "VHS_VIDEOINFO" + ], + [ + 88, + 45, + 0, + 46, + 0, + "IMAGE" + ], + [ + 89, + 46, + 0, + 5, + 0, + "IMAGE" + ], + [ + 90, + 45, + 1, + 47, + 0, + "IMAGE" + ], + [ + 91, + 47, + 0, + 42, + 0, + "IMAGE" + ], + [ + 92, + 2, + 0, + 48, + 0, + "IMAGE" + ], + [ + 93, + 48, + 0, + 45, + 0, + "IMAGE" + ], + [ + 94, + 48, + 0, + 15, + 0, + "IMAGE" + ], + [ + 95, + 39, + 0, + 49, + 0, + "IMAGE" + ], + [ + 96, + 49, + 0, + 45, + 3, + "IMAGE" + ], + [ + 97, + 49, + 0, + 15, + 3, + "IMAGE" + ], + [ + 98, + 3, + 0, + 50, + 0, + "IMAGE" + ], + [ + 99, + 50, + 0, + 45, + 1, + "IMAGE" + ], + [ + 100, + 50, + 0, + 15, + 1, + "IMAGE" + ], + [ + 101, + 40, + 0, + 51, + 0, + "FLOAT" + ], + [ + 102, + 51, + 0, + 42, + 4, + "FLOAT" + ], + [ + 103, + 51, + 0, + 5, + 4, + "FLOAT" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.8264462809917354, + "offset": [ + 1075.4186904316002, + -106.66962539008848 + ] + }, + "reroutes": [ + { + "id": 3, + "pos": [ + 1139.3179931640625, + 206.41610717773438 + ], + "linkIds": [ + 19, + 49 + ] + } + ], + "VHS_latentpreview": false, + "VHS_latentpreviewrate": 0, + "VHS_MetadataImage": true, + "VHS_KeepIntermediate": true, + "linkExtensions": [ + { + "id": 19, + "parentId": 3 + }, + { + "id": 49, + "parentId": 3 + } + ] + }, + "version": 0.4 +} \ No newline at end of file