diff --git "a/huggingface_segment-anything-2.txt" "b/huggingface_segment-anything-2.txt" new file mode 100644--- /dev/null +++ "b/huggingface_segment-anything-2.txt" @@ -0,0 +1,2645 @@ +# File: segment-anything-2-coreml-conversion/coreml/export.py +import argparse +import os +import enum +from typing import List, Optional, Tuple +import ast +import torch +import numpy as np +from PIL import Image +from PIL.Image import Resampling +import coremltools as ct +from coremltools.converters.mil._deployment_compatibility import AvailableTarget +from coremltools import ComputeUnit +from coremltools.converters.mil.mil.passes.defs.quantization import ComputePrecision +from coremltools.converters.mil import register_torch_op +from coremltools.converters.mil.mil import Builder as mb +from sam2.sam2_image_predictor import SAM2ImagePredictor + +class SAM2Variant(enum.Enum): + Tiny = 'tiny' + Small = 'small' + BasePlus = 'base-plus' + Large = 'large' + + def fmt(self): + if self == SAM2Variant.BasePlus: + return 'BasePlus' + return self.value.capitalize() +SAM2_HW = (1024, 1024) + +def parse_args(parser: argparse.ArgumentParser) -> argparse.ArgumentParser: + parser.add_argument('--output-dir', type=str, default='.', help='Provide location to save exported models.') + parser.add_argument('--variant', type=lambda x: getattr(SAM2Variant, x), choices=[variant for variant in SAM2Variant], default=SAM2Variant.Small, help='SAM2 variant to export.') + parser.add_argument('--points', type=str, help="List of 2D points, e.g., '[[10,20], [30,40]]'") + parser.add_argument('--boxes', type=str, help="List of 2D bounding boxes, e.g., '[[10,20,30,40], [50,60,70,80]]'") + parser.add_argument('--labels', type=str, help='List of binary labels for each points entry, denoting foreground (1) or background (0).') + parser.add_argument('--min-deployment-target', type=lambda x: getattr(AvailableTarget, x), choices=[target for target in AvailableTarget], default=AvailableTarget.iOS17, help='Minimum deployment target for CoreML model.') + parser.add_argument('--compute-units', type=lambda x: getattr(ComputeUnit, x), choices=[cu for cu in ComputeUnit], default=ComputeUnit.ALL, help='Which compute units to target for CoreML model.') + parser.add_argument('--precision', type=lambda x: getattr(ComputePrecision, x), choices=[p for p in ComputePrecision], default=ComputePrecision.FLOAT16, help='Precision to use for quantization.') + return parser + +@register_torch_op +def upsample_bicubic2d(context, node): + x = context[node.inputs[0]] + output_size = context[node.inputs[1]].val + scale_factor_height = output_size[0] / x.shape[2] + scale_factor_width = output_size[1] / x.shape[3] + align_corners = context[node.inputs[2]].val + x = mb.upsample_bilinear(x=x, scale_factor_height=scale_factor_height, scale_factor_width=scale_factor_width, align_corners=align_corners, name=node.name) + context.add(x) + +class SAM2ImageEncoder(torch.nn.Module): + + def __init__(self, model: SAM2ImagePredictor): + super().__init__() + self.model = model + + @torch.no_grad() + def forward(self, image): + (img_embedding, feats_s0, feats_s1) = self.model.encode_image_raw(image) + return (img_embedding, feats_s0, feats_s1) + +def validate_image_encoder(model: ct.models.MLModel, ground_model: SAM2ImagePredictor, image: Image.Image): + prepared_image = image.resize(SAM2_HW, Resampling.BILINEAR) + predictions = model.predict({'image': prepared_image}) + image = np.array(image.convert('RGB')) + tch_image = ground_model._transforms(image) + tch_image = tch_image[None, ...].to('cpu') + (ground_embedding, ground_feats_s0, ground_feats_s1) = ground_model.encode_image_raw(tch_image) + (ground_embedding, ground_feats_s0, ground_feats_s1) = (ground_embedding.numpy(), ground_feats_s0.numpy(), ground_feats_s1.numpy()) + img_max_diff = np.max(np.abs(predictions['image_embedding'] - ground_embedding)) + img_avg_diff = np.mean(np.abs(predictions['image_embedding'] - ground_embedding)) + s0_max_diff = np.max(np.abs(predictions['feats_s0'] - ground_feats_s0)) + s0_avg_diff = np.mean(np.abs(predictions['feats_s0'] - ground_feats_s0)) + s1_max_diff = np.max(np.abs(predictions['feats_s1'] - ground_feats_s1)) + s1_avg_diff = np.mean(np.abs(predictions['feats_s1'] - ground_feats_s1)) + print(f'Image Embedding: Max Diff: {img_max_diff:.4f}, Avg Diff: {img_avg_diff:.4f}') + print(f'Feats S0: Max Diff: {s0_max_diff:.4f}, Avg Diff: {s0_avg_diff:.4f}') + print(f'Feats S1: Max Diff: {s1_max_diff:.4f}, Avg Diff: {s1_avg_diff:.4f}') + +def validate_prompt_encoder(model: ct.models.MLModel, ground_model: SAM2ImagePredictor, unnorm_coords, labels): + predictions = model.predict({'points': unnorm_coords, 'labels': labels}) + (ground_sparse, ground_dense) = ground_model.encode_points_raw(unnorm_coords, labels) + ground_sparse = ground_sparse.numpy() + ground_dense = ground_dense.numpy() + sparse_max_diff = np.max(np.abs(predictions['sparse_embeddings'] - ground_sparse)) + sparse_avg_diff = np.mean(np.abs(predictions['sparse_embeddings'] - ground_sparse)) + dense_max_diff = np.max(np.abs(predictions['dense_embeddings'] - ground_dense)) + dense_avg_diff = np.mean(np.abs(predictions['dense_embeddings'] - ground_dense)) + print('Sparse Embeddings: Max Diff: {:.4f}, Avg Diff: {:.4f}'.format(sparse_max_diff, sparse_avg_diff)) + print('Dense Embeddings: Max Diff: {:.4f}, Avg Diff: {:.4f}'.format(dense_max_diff, dense_avg_diff)) + assert np.allclose(predictions['sparse_embeddings'], ground_sparse, atol=0.009) + assert np.allclose(predictions['dense_embeddings'], ground_dense, atol=0.001) + +def validate_mask_decoder(model: ct.models.MLModel, ground_model: SAM2ImagePredictor, image_embedding, sparse_embedding, dense_embedding, feats_s0, feats_s1, precision: ComputePrecision): + predictions = model.predict({'image_embedding': image_embedding, 'sparse_embedding': sparse_embedding, 'dense_embedding': dense_embedding, 'feats_s0': feats_s0, 'feats_s1': feats_s1}) + (ground_masks, scores) = ground_model.decode_masks_raw(image_embedding, sparse_embedding, dense_embedding, [feats_s0, feats_s1]) + ground_masks = ground_masks.numpy() + masks_max_diff = np.max(np.abs(predictions['low_res_masks'] - ground_masks)) + masks_avg_diff = np.mean(np.abs(predictions['low_res_masks'] - ground_masks)) + print('Masks: Max Diff: {:.4f}, Avg Diff: {:.4f}'.format(masks_max_diff, masks_avg_diff)) + atol = 0.07 if precision == ComputePrecision.FLOAT32 else 0.3 + assert np.allclose(predictions['low_res_masks'], ground_masks, atol=atol) + print(f"Scores: {predictions['scores']}, ground: {scores}") + +class SAM2PointsEncoder(torch.nn.Module): + + def __init__(self, model: SAM2ImagePredictor): + super().__init__() + self.model = model + + @torch.no_grad() + def forward(self, points, labels): + prompt_embedding = self.model.encode_points_raw(points, labels) + return prompt_embedding + +class SAM2MaskDecoder(torch.nn.Module): + + def __init__(self, model: SAM2ImagePredictor): + super().__init__() + self.model = model + + @torch.no_grad() + def forward(self, image_embedding, sparse_embedding, dense_embedding, feats_s0, feats_s1): + (low_res_masks, iou_scores) = self.model.decode_masks_raw(image_embedding, sparse_embedding, dense_embedding, [feats_s0, feats_s1]) + return (low_res_masks, iou_scores) + +def export_image_encoder(image_predictor: SAM2ImagePredictor, variant: SAM2Variant, output_dir: str, min_target: AvailableTarget, compute_units: ComputeUnit, precision: ComputePrecision) -> Tuple[int, int]: + image = Image.open('../notebooks/images/truck.jpg') + image = np.array(image.convert('RGB')) + orig_hw = (image.shape[0], image.shape[1]) + prepared_image = image_predictor._transforms(image) + prepared_image = prepared_image[None, ...].to('cpu') + traced_model = torch.jit.trace(SAM2ImageEncoder(image_predictor).eval(), prepared_image) + scale = 1 / (0.226 * 255.0) + bias = [-0.485 / 0.229, -0.456 / 0.224, -0.406 / 0.225] + mlmodel = ct.convert(traced_model, inputs=[ct.ImageType(name='image', shape=(1, 3, SAM2_HW[0], SAM2_HW[1]), scale=scale, bias=bias)], outputs=[ct.TensorType(name='image_embedding'), ct.TensorType(name='feats_s0'), ct.TensorType(name='feats_s1')], minimum_deployment_target=min_target, compute_units=compute_units, compute_precision=precision) + image = Image.open('../notebooks/images/truck.jpg') + validate_image_encoder(mlmodel, image_predictor, image) + output_path = os.path.join(output_dir, f'SAM2{variant.fmt()}ImageEncoder{precision.value.upper()}') + mlmodel.save(output_path + '.mlpackage') + return orig_hw + +def export_points_prompt_encoder(image_predictor: SAM2ImagePredictor, variant: SAM2Variant, input_points: List[List[float]], input_labels: List[int], orig_hw: tuple, output_dir: str, min_target: AvailableTarget, compute_units: ComputeUnit, precision: ComputePrecision): + image_predictor.model.sam_prompt_encoder.eval() + points = torch.tensor(input_points, dtype=torch.float32) + labels = torch.tensor(input_labels, dtype=torch.int32) + unnorm_coords = image_predictor._transforms.transform_coords(points, normalize=True, orig_hw=orig_hw) + (unnorm_coords, labels) = (unnorm_coords[None, ...], labels[None, ...]) + traced_model = torch.jit.trace(SAM2PointsEncoder(image_predictor), (unnorm_coords, labels)) + points_shape = ct.Shape(shape=(1, ct.RangeDim(lower_bound=1, upper_bound=16), 2)) + labels_shape = ct.Shape(shape=(1, ct.RangeDim(lower_bound=1, upper_bound=16))) + mlmodel = ct.convert(traced_model, inputs=[ct.TensorType(name='points', shape=points_shape), ct.TensorType(name='labels', shape=labels_shape)], outputs=[ct.TensorType(name='sparse_embeddings'), ct.TensorType(name='dense_embeddings')], minimum_deployment_target=min_target, compute_units=compute_units, compute_precision=precision) + validate_prompt_encoder(mlmodel, image_predictor, unnorm_coords, labels) + output_path = os.path.join(output_dir, f'SAM2{variant.fmt()}PromptEncoder{precision.value.upper()}') + mlmodel.save(output_path + '.mlpackage') + +def export_mask_decoder(image_predictor: SAM2ImagePredictor, variant: SAM2Variant, output_dir: str, min_target: AvailableTarget, compute_units: ComputeUnit, precision: ComputePrecision): + image_predictor.model.sam_mask_decoder.eval() + s0 = torch.randn(1, 32, 256, 256) + s1 = torch.randn(1, 64, 128, 128) + image_embedding = torch.randn(1, 256, 64, 64) + sparse_embedding = torch.randn(1, 3, 256) + dense_embedding = torch.randn(1, 256, 64, 64) + traced_model = torch.jit.trace(SAM2MaskDecoder(image_predictor), (image_embedding, sparse_embedding, dense_embedding, s0, s1)) + traced_model.eval() + mlmodel = ct.convert(traced_model, inputs=[ct.TensorType(name='image_embedding', shape=[1, 256, 64, 64]), ct.TensorType(name='sparse_embedding', shape=ct.EnumeratedShapes(shapes=[[1, i, 256] for i in range(2, 16)])), ct.TensorType(name='dense_embedding', shape=[1, 256, 64, 64]), ct.TensorType(name='feats_s0', shape=[1, 32, 256, 256]), ct.TensorType(name='feats_s1', shape=[1, 64, 128, 128])], outputs=[ct.TensorType(name='low_res_masks'), ct.TensorType(name='scores')], minimum_deployment_target=min_target, compute_units=compute_units, compute_precision=precision) + validate_mask_decoder(mlmodel, image_predictor, image_embedding, sparse_embedding, dense_embedding, s0, s1, precision) + output_path = os.path.join(output_dir, f'SAM2{variant.fmt()}MaskDecoder{precision.value.upper()}') + mlmodel.save(output_path + '.mlpackage') +Point = Tuple[float, float] +Box = Tuple[float, float, float, float] + +def export(output_dir: str, variant: SAM2Variant, points: Optional[List[Point]], boxes: Optional[List[Box]], labels: Optional[List[int]], min_target: AvailableTarget, compute_units: ComputeUnit, precision: ComputePrecision): + os.makedirs(output_dir, exist_ok=True) + device = torch.device('cpu') + sam2_checkpoint = f'facebook/sam2-hiera-{variant.value}' + with torch.no_grad(): + img_predictor = SAM2ImagePredictor.from_pretrained(sam2_checkpoint, device=device) + img_predictor.model.eval() + orig_hw = export_image_encoder(img_predictor, variant, output_dir, min_target, compute_units, precision) + if boxes is not None and points is None: + raise ValueError('Boxes are not supported yet') + else: + export_points_prompt_encoder(img_predictor, variant, points, labels, orig_hw, output_dir, min_target, compute_units, precision) + export_mask_decoder(img_predictor, variant, output_dir, min_target, compute_units, precision) +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='SAM2 -> CoreML CLI') + parser = parse_args(parser) + args = parser.parse_args() + (points, boxes, labels) = (None, None, None) + if args.points: + points = [tuple(p) for p in ast.literal_eval(args.points)] + if args.boxes: + boxes = [tuple(b) for b in ast.literal_eval(args.boxes)] + if args.labels: + labels = ast.literal_eval(args.labels) + if boxes and points: + raise ValueError('Cannot provide both points and boxes') + if points: + if not isinstance(points, list) or not all((isinstance(p, tuple) and len(p) == 2 for p in points)): + raise ValueError('Points must be a tuple of 2D points') + if labels: + if not isinstance(labels, list) or not all((isinstance(l, int) and l in [0, 1] for l in labels)): + raise ValueError('Labels must denote foreground (1) or background (0)') + if points: + if len(points) != len(labels): + raise ValueError('Number of points must match the number of labels') + if len(points) > 16: + raise ValueError('Number of points must be less than or equal to 16') + if boxes: + if not isinstance(boxes, list) or not all((isinstance(b, tuple) and len(b) == 4 for b in boxes)): + raise ValueError('Boxes must be a tuple of 4D bounding boxes') + export(args.output_dir, args.variant, points, boxes, labels, args.min_deployment_target, args.compute_units, args.precision) + +# File: segment-anything-2-coreml-conversion/sam2/automatic_mask_generator.py +from typing import Any, Dict, List, Optional, Tuple +import numpy as np +import torch +from torchvision.ops.boxes import batched_nms, box_area +from sam2.modeling.sam2_base import SAM2Base +from sam2.sam2_image_predictor import SAM2ImagePredictor +from sam2.utils.amg import area_from_rle, batch_iterator, batched_mask_to_box, box_xyxy_to_xywh, build_all_layer_point_grids, calculate_stability_score, coco_encode_rle, generate_crop_boxes, is_box_near_crop_edge, mask_to_rle_pytorch, MaskData, remove_small_regions, rle_to_mask, uncrop_boxes_xyxy, uncrop_masks, uncrop_points + +class SAM2AutomaticMaskGenerator: + + def __init__(self, model: SAM2Base, points_per_side: Optional[int]=32, points_per_batch: int=64, pred_iou_thresh: float=0.8, stability_score_thresh: float=0.95, stability_score_offset: float=1.0, mask_threshold: float=0.0, box_nms_thresh: float=0.7, crop_n_layers: int=0, crop_nms_thresh: float=0.7, crop_overlap_ratio: float=512 / 1500, crop_n_points_downscale_factor: int=1, point_grids: Optional[List[np.ndarray]]=None, min_mask_region_area: int=0, output_mode: str='binary_mask', use_m2m: bool=False, multimask_output: bool=True, **kwargs) -> None: + assert (points_per_side is None) != (point_grids is None), 'Exactly one of points_per_side or point_grid must be provided.' + if points_per_side is not None: + self.point_grids = build_all_layer_point_grids(points_per_side, crop_n_layers, crop_n_points_downscale_factor) + elif point_grids is not None: + self.point_grids = point_grids + else: + raise ValueError("Can't have both points_per_side and point_grid be None.") + assert output_mode in ['binary_mask', 'uncompressed_rle', 'coco_rle'], f'Unknown output_mode {output_mode}.' + if output_mode == 'coco_rle': + try: + from pycocotools import mask as mask_utils + except ImportError as e: + print('Please install pycocotools') + raise e + self.predictor = SAM2ImagePredictor(model, max_hole_area=min_mask_region_area, max_sprinkle_area=min_mask_region_area) + self.points_per_batch = points_per_batch + self.pred_iou_thresh = pred_iou_thresh + self.stability_score_thresh = stability_score_thresh + self.stability_score_offset = stability_score_offset + self.mask_threshold = mask_threshold + self.box_nms_thresh = box_nms_thresh + self.crop_n_layers = crop_n_layers + self.crop_nms_thresh = crop_nms_thresh + self.crop_overlap_ratio = crop_overlap_ratio + self.crop_n_points_downscale_factor = crop_n_points_downscale_factor + self.min_mask_region_area = min_mask_region_area + self.output_mode = output_mode + self.use_m2m = use_m2m + self.multimask_output = multimask_output + + @classmethod + def from_pretrained(cls, model_id: str, **kwargs) -> 'SAM2AutomaticMaskGenerator': + from sam2.build_sam import build_sam2_hf + sam_model = build_sam2_hf(model_id, **kwargs) + return cls(sam_model, **kwargs) + + @torch.no_grad() + def generate(self, image: np.ndarray) -> List[Dict[str, Any]]: + mask_data = self._generate_masks(image) + if self.output_mode == 'coco_rle': + mask_data['segmentations'] = [coco_encode_rle(rle) for rle in mask_data['rles']] + elif self.output_mode == 'binary_mask': + mask_data['segmentations'] = [rle_to_mask(rle) for rle in mask_data['rles']] + else: + mask_data['segmentations'] = mask_data['rles'] + curr_anns = [] + for idx in range(len(mask_data['segmentations'])): + ann = {'segmentation': mask_data['segmentations'][idx], 'area': area_from_rle(mask_data['rles'][idx]), 'bbox': box_xyxy_to_xywh(mask_data['boxes'][idx]).tolist(), 'predicted_iou': mask_data['iou_preds'][idx].item(), 'point_coords': [mask_data['points'][idx].tolist()], 'stability_score': mask_data['stability_score'][idx].item(), 'crop_box': box_xyxy_to_xywh(mask_data['crop_boxes'][idx]).tolist()} + curr_anns.append(ann) + return curr_anns + + def _generate_masks(self, image: np.ndarray) -> MaskData: + orig_size = image.shape[:2] + (crop_boxes, layer_idxs) = generate_crop_boxes(orig_size, self.crop_n_layers, self.crop_overlap_ratio) + data = MaskData() + for (crop_box, layer_idx) in zip(crop_boxes, layer_idxs): + crop_data = self._process_crop(image, crop_box, layer_idx, orig_size) + data.cat(crop_data) + if len(crop_boxes) > 1: + scores = 1 / box_area(data['crop_boxes']) + scores = scores.to(data['boxes'].device) + keep_by_nms = batched_nms(data['boxes'].float(), scores, torch.zeros_like(data['boxes'][:, 0]), iou_threshold=self.crop_nms_thresh) + data.filter(keep_by_nms) + data.to_numpy() + return data + + def _process_crop(self, image: np.ndarray, crop_box: List[int], crop_layer_idx: int, orig_size: Tuple[int, ...]) -> MaskData: + (x0, y0, x1, y1) = crop_box + cropped_im = image[y0:y1, x0:x1, :] + cropped_im_size = cropped_im.shape[:2] + self.predictor.set_image(cropped_im) + points_scale = np.array(cropped_im_size)[None, ::-1] + points_for_image = self.point_grids[crop_layer_idx] * points_scale + data = MaskData() + for (points,) in batch_iterator(self.points_per_batch, points_for_image): + batch_data = self._process_batch(points, cropped_im_size, crop_box, orig_size, normalize=True) + data.cat(batch_data) + del batch_data + self.predictor.reset_predictor() + keep_by_nms = batched_nms(data['boxes'].float(), data['iou_preds'], torch.zeros_like(data['boxes'][:, 0]), iou_threshold=self.box_nms_thresh) + data.filter(keep_by_nms) + data['boxes'] = uncrop_boxes_xyxy(data['boxes'], crop_box) + data['points'] = uncrop_points(data['points'], crop_box) + data['crop_boxes'] = torch.tensor([crop_box for _ in range(len(data['rles']))]) + return data + + def _process_batch(self, points: np.ndarray, im_size: Tuple[int, ...], crop_box: List[int], orig_size: Tuple[int, ...], normalize=False) -> MaskData: + (orig_h, orig_w) = orig_size + points = torch.as_tensor(points, dtype=torch.float32, device=self.predictor.device) + in_points = self.predictor._transforms.transform_coords(points, normalize=normalize, orig_hw=im_size) + in_labels = torch.ones(in_points.shape[0], dtype=torch.int, device=in_points.device) + (masks, iou_preds, low_res_masks) = self.predictor._predict(in_points[:, None, :], in_labels[:, None], multimask_output=self.multimask_output, return_logits=True) + data = MaskData(masks=masks.flatten(0, 1), iou_preds=iou_preds.flatten(0, 1), points=points.repeat_interleave(masks.shape[1], dim=0), low_res_masks=low_res_masks.flatten(0, 1)) + del masks + if not self.use_m2m: + if self.pred_iou_thresh > 0.0: + keep_mask = data['iou_preds'] > self.pred_iou_thresh + data.filter(keep_mask) + data['stability_score'] = calculate_stability_score(data['masks'], self.mask_threshold, self.stability_score_offset) + if self.stability_score_thresh > 0.0: + keep_mask = data['stability_score'] >= self.stability_score_thresh + data.filter(keep_mask) + else: + in_points = self.predictor._transforms.transform_coords(data['points'], normalize=normalize, orig_hw=im_size) + labels = torch.ones(in_points.shape[0], dtype=torch.int, device=in_points.device) + (masks, ious) = self.refine_with_m2m(in_points, labels, data['low_res_masks'], self.points_per_batch) + data['masks'] = masks.squeeze(1) + data['iou_preds'] = ious.squeeze(1) + if self.pred_iou_thresh > 0.0: + keep_mask = data['iou_preds'] > self.pred_iou_thresh + data.filter(keep_mask) + data['stability_score'] = calculate_stability_score(data['masks'], self.mask_threshold, self.stability_score_offset) + if self.stability_score_thresh > 0.0: + keep_mask = data['stability_score'] >= self.stability_score_thresh + data.filter(keep_mask) + data['masks'] = data['masks'] > self.mask_threshold + data['boxes'] = batched_mask_to_box(data['masks']) + keep_mask = ~is_box_near_crop_edge(data['boxes'], crop_box, [0, 0, orig_w, orig_h]) + if not torch.all(keep_mask): + data.filter(keep_mask) + data['masks'] = uncrop_masks(data['masks'], crop_box, orig_h, orig_w) + data['rles'] = mask_to_rle_pytorch(data['masks']) + del data['masks'] + return data + + @staticmethod + def postprocess_small_regions(mask_data: MaskData, min_area: int, nms_thresh: float) -> MaskData: + if len(mask_data['rles']) == 0: + return mask_data + new_masks = [] + scores = [] + for rle in mask_data['rles']: + mask = rle_to_mask(rle) + (mask, changed) = remove_small_regions(mask, min_area, mode='holes') + unchanged = not changed + (mask, changed) = remove_small_regions(mask, min_area, mode='islands') + unchanged = unchanged and (not changed) + new_masks.append(torch.as_tensor(mask).unsqueeze(0)) + scores.append(float(unchanged)) + masks = torch.cat(new_masks, dim=0) + boxes = batched_mask_to_box(masks) + keep_by_nms = batched_nms(boxes.float(), torch.as_tensor(scores), torch.zeros_like(boxes[:, 0]), iou_threshold=nms_thresh) + for i_mask in keep_by_nms: + if scores[i_mask] == 0.0: + mask_torch = masks[i_mask].unsqueeze(0) + mask_data['rles'][i_mask] = mask_to_rle_pytorch(mask_torch)[0] + mask_data['boxes'][i_mask] = boxes[i_mask] + mask_data.filter(keep_by_nms) + return mask_data + + def refine_with_m2m(self, points, point_labels, low_res_masks, points_per_batch): + new_masks = [] + new_iou_preds = [] + for (cur_points, cur_point_labels, low_res_mask) in batch_iterator(points_per_batch, points, point_labels, low_res_masks): + (best_masks, best_iou_preds, _) = self.predictor._predict(cur_points[:, None, :], cur_point_labels[:, None], mask_input=low_res_mask[:, None, :], multimask_output=False, return_logits=True) + new_masks.append(best_masks) + new_iou_preds.append(best_iou_preds) + masks = torch.cat(new_masks, dim=0) + return (masks, torch.cat(new_iou_preds, dim=0)) + +# File: segment-anything-2-coreml-conversion/sam2/build_sam.py +import logging +import torch +from hydra import compose +from hydra.utils import instantiate +from omegaconf import OmegaConf + +def build_sam2(config_file, ckpt_path=None, device='cuda', mode='eval', hydra_overrides_extra=[], apply_postprocessing=True, **kwargs): + if apply_postprocessing: + hydra_overrides_extra = hydra_overrides_extra.copy() + hydra_overrides_extra += ['++model.sam_mask_decoder_extra_args.dynamic_multimask_via_stability=true', '++model.sam_mask_decoder_extra_args.dynamic_multimask_stability_delta=0.05', '++model.sam_mask_decoder_extra_args.dynamic_multimask_stability_thresh=0.98'] + cfg = compose(config_name=config_file, overrides=hydra_overrides_extra) + OmegaConf.resolve(cfg) + model = instantiate(cfg.model, _recursive_=True) + _load_checkpoint(model, ckpt_path) + model = model.to(device) + if mode == 'eval': + model.eval() + return model + +def build_sam2_video_predictor(config_file, ckpt_path=None, device='cuda', mode='eval', hydra_overrides_extra=[], apply_postprocessing=True, **kwargs): + hydra_overrides = ['++model._target_=sam2.sam2_video_predictor.SAM2VideoPredictor'] + if apply_postprocessing: + hydra_overrides_extra = hydra_overrides_extra.copy() + hydra_overrides_extra += ['++model.sam_mask_decoder_extra_args.dynamic_multimask_via_stability=true', '++model.sam_mask_decoder_extra_args.dynamic_multimask_stability_delta=0.05', '++model.sam_mask_decoder_extra_args.dynamic_multimask_stability_thresh=0.98', '++model.binarize_mask_from_pts_for_mem_enc=true', '++model.fill_hole_area=8'] + hydra_overrides.extend(hydra_overrides_extra) + cfg = compose(config_name=config_file, overrides=hydra_overrides) + OmegaConf.resolve(cfg) + model = instantiate(cfg.model, _recursive_=True) + _load_checkpoint(model, ckpt_path) + model = model.to(device) + if mode == 'eval': + model.eval() + return model + +def build_sam2_hf(model_id, **kwargs): + from huggingface_hub import hf_hub_download + model_id_to_filenames = {'facebook/sam2-hiera-tiny': ('sam2_hiera_t.yaml', 'sam2_hiera_tiny.pt'), 'facebook/sam2-hiera-small': ('sam2_hiera_s.yaml', 'sam2_hiera_small.pt'), 'facebook/sam2-hiera-base-plus': ('sam2_hiera_b+.yaml', 'sam2_hiera_base_plus.pt'), 'facebook/sam2-hiera-large': ('sam2_hiera_l.yaml', 'sam2_hiera_large.pt')} + (config_name, checkpoint_name) = model_id_to_filenames[model_id] + ckpt_path = hf_hub_download(repo_id=model_id, filename=checkpoint_name) + return build_sam2(config_file=config_name, ckpt_path=ckpt_path, **kwargs) + +def build_sam2_video_predictor_hf(model_id, **kwargs): + from huggingface_hub import hf_hub_download + model_id_to_filenames = {'facebook/sam2-hiera-tiny': ('sam2_hiera_t.yaml', 'sam2_hiera_tiny.pt'), 'facebook/sam2-hiera-small': ('sam2_hiera_s.yaml', 'sam2_hiera_small.pt'), 'facebook/sam2-hiera-base-plus': ('sam2_hiera_b+.yaml', 'sam2_hiera_base_plus.pt'), 'facebook/sam2-hiera-large': ('sam2_hiera_l.yaml', 'sam2_hiera_large.pt')} + (config_name, checkpoint_name) = model_id_to_filenames[model_id] + ckpt_path = hf_hub_download(repo_id=model_id, filename=checkpoint_name) + return build_sam2_video_predictor(config_file=config_name, ckpt_path=ckpt_path, **kwargs) + +def _load_checkpoint(model, ckpt_path): + if ckpt_path is not None: + sd = torch.load(ckpt_path, map_location='cpu')['model'] + (missing_keys, unexpected_keys) = model.load_state_dict(sd) + if missing_keys: + logging.error(missing_keys) + raise RuntimeError() + if unexpected_keys: + logging.error(unexpected_keys) + raise RuntimeError() + logging.info('Loaded checkpoint sucessfully') + +# File: segment-anything-2-coreml-conversion/sam2/modeling/backbones/hieradet.py +from functools import partial +from typing import List, Tuple, Union +import torch +import torch.nn as nn +import torch.nn.functional as F +from sam2.modeling.backbones.utils import PatchEmbed, window_partition, window_unpartition +from sam2.modeling.sam2_utils import DropPath, MLP + +def do_pool(x: torch.Tensor, pool: nn.Module, norm: nn.Module=None) -> torch.Tensor: + if pool is None: + return x + x = x.permute(0, 3, 1, 2) + x = pool(x) + x = x.permute(0, 2, 3, 1) + if norm: + x = norm(x) + return x + +class MultiScaleAttention(nn.Module): + + def __init__(self, dim: int, dim_out: int, num_heads: int, q_pool: nn.Module=None): + super().__init__() + self.dim = dim + self.dim_out = dim_out + self.num_heads = num_heads + self.q_pool = q_pool + self.qkv = nn.Linear(dim, dim_out * 3) + self.proj = nn.Linear(dim_out, dim_out) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + (B, H, W, _) = x.shape + qkv = self.qkv(x).reshape(B, H * W, 3, self.num_heads, -1) + (q, k, v) = torch.unbind(qkv, 2) + if self.q_pool: + q = do_pool(q.reshape(B, H, W, -1), self.q_pool) + (H, W) = q.shape[1:3] + q = q.reshape(B, H * W, self.num_heads, -1) + x = F.scaled_dot_product_attention(q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)) + x = x.transpose(1, 2) + x = x.reshape(B, H, W, -1) + x = self.proj(x) + return x + +class MultiScaleBlock(nn.Module): + + def __init__(self, dim: int, dim_out: int, num_heads: int, mlp_ratio: float=4.0, drop_path: float=0.0, norm_layer: Union[nn.Module, str]='LayerNorm', q_stride: Tuple[int, int]=None, act_layer: nn.Module=nn.GELU, window_size: int=0): + super().__init__() + if isinstance(norm_layer, str): + norm_layer = partial(getattr(nn, norm_layer), eps=1e-06) + self.dim = dim + self.dim_out = dim_out + self.norm1 = norm_layer(dim) + self.window_size = window_size + (self.pool, self.q_stride) = (None, q_stride) + if self.q_stride: + self.pool = nn.MaxPool2d(kernel_size=q_stride, stride=q_stride, ceil_mode=False) + self.attn = MultiScaleAttention(dim, dim_out, num_heads=num_heads, q_pool=self.pool) + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + self.norm2 = norm_layer(dim_out) + self.mlp = MLP(dim_out, int(dim_out * mlp_ratio), dim_out, num_layers=2, activation=act_layer) + if dim != dim_out: + self.proj = nn.Linear(dim, dim_out) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + shortcut = x + x = self.norm1(x) + if self.dim != self.dim_out: + shortcut = do_pool(self.proj(x), self.pool) + window_size = self.window_size + if window_size > 0: + (H, W) = (x.shape[1], x.shape[2]) + (x, pad_hw) = window_partition(x, window_size) + x = self.attn(x) + if self.q_stride: + window_size = self.window_size // self.q_stride[0] + (H, W) = shortcut.shape[1:3] + pad_h = (window_size - H % window_size) % window_size + pad_w = (window_size - W % window_size) % window_size + pad_hw = (H + pad_h, W + pad_w) + if self.window_size > 0: + x = window_unpartition(x, window_size, pad_hw, (H, W)) + x = shortcut + self.drop_path(x) + x = x + self.drop_path(self.mlp(self.norm2(x))) + return x + +class Hiera(nn.Module): + + def __init__(self, embed_dim: int=96, num_heads: int=1, drop_path_rate: float=0.0, q_pool: int=3, q_stride: Tuple[int, int]=(2, 2), stages: Tuple[int, ...]=(2, 3, 16, 3), dim_mul: float=2.0, head_mul: float=2.0, window_pos_embed_bkg_spatial_size: Tuple[int, int]=(14, 14), window_spec: Tuple[int, ...]=(8, 4, 14, 7), global_att_blocks: Tuple[int, ...]=(12, 16, 20), return_interm_layers=True): + super().__init__() + assert len(stages) == len(window_spec) + self.window_spec = window_spec + depth = sum(stages) + self.q_stride = q_stride + self.stage_ends = [sum(stages[:i]) - 1 for i in range(1, len(stages) + 1)] + assert 0 <= q_pool <= len(self.stage_ends[:-1]) + self.q_pool_blocks = [x + 1 for x in self.stage_ends[:-1]][:q_pool] + self.return_interm_layers = return_interm_layers + self.patch_embed = PatchEmbed(embed_dim=embed_dim) + self.global_att_blocks = global_att_blocks + self.window_pos_embed_bkg_spatial_size = window_pos_embed_bkg_spatial_size + self.pos_embed = nn.Parameter(torch.zeros(1, embed_dim, *self.window_pos_embed_bkg_spatial_size)) + self.pos_embed_window = nn.Parameter(torch.zeros(1, embed_dim, self.window_spec[0], self.window_spec[0])) + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] + cur_stage = 1 + self.blocks = nn.ModuleList() + for i in range(depth): + dim_out = embed_dim + window_size = self.window_spec[cur_stage - 1] + if self.global_att_blocks is not None: + window_size = 0 if i in self.global_att_blocks else window_size + if i - 1 in self.stage_ends: + dim_out = int(embed_dim * dim_mul) + num_heads = int(num_heads * head_mul) + cur_stage += 1 + block = MultiScaleBlock(dim=embed_dim, dim_out=dim_out, num_heads=num_heads, drop_path=dpr[i], q_stride=self.q_stride if i in self.q_pool_blocks else None, window_size=window_size) + embed_dim = dim_out + self.blocks.append(block) + self.channel_list = [self.blocks[i].dim_out for i in self.stage_ends[::-1]] if return_interm_layers else [self.blocks[-1].dim_out] + + def _get_pos_embed(self, hw: Tuple[int, int]) -> torch.Tensor: + (h, w) = hw + window_embed = self.pos_embed_window + pos_embed = F.interpolate(self.pos_embed, size=(h, w), mode='bicubic') + tiles = [x // y for (x, y) in zip(pos_embed.shape, window_embed.shape)] + pos_embed = pos_embed + window_embed.tile(tiles) + pos_embed = pos_embed.permute(0, 2, 3, 1) + return pos_embed + + def forward(self, x: torch.Tensor) -> List[torch.Tensor]: + x = self.patch_embed(x) + x = x + self._get_pos_embed(x.shape[1:3]) + outputs = [] + for (i, blk) in enumerate(self.blocks): + x = blk(x) + if i == self.stage_ends[-1] or (i in self.stage_ends and self.return_interm_layers): + feats = x.permute(0, 3, 1, 2) + outputs.append(feats) + return outputs + +# File: segment-anything-2-coreml-conversion/sam2/modeling/backbones/image_encoder.py +from typing import List, Optional +import torch +import torch.nn as nn +import torch.nn.functional as F + +class ImageEncoder(nn.Module): + + def __init__(self, trunk: nn.Module, neck: nn.Module, scalp: int=0): + super().__init__() + self.trunk = trunk + self.neck = neck + self.scalp = scalp + assert self.trunk.channel_list == self.neck.backbone_channel_list, f'Channel dims of trunk and neck do not match. Trunk: {self.trunk.channel_list}, neck: {self.neck.backbone_channel_list}' + + def forward(self, sample: torch.Tensor): + (features, pos) = self.neck(self.trunk(sample)) + if self.scalp > 0: + (features, pos) = (features[:-self.scalp], pos[:-self.scalp]) + src = features[-1] + output = {'vision_features': src, 'vision_pos_enc': pos, 'backbone_fpn': features} + return output + +class FpnNeck(nn.Module): + + def __init__(self, position_encoding: nn.Module, d_model: int, backbone_channel_list: List[int], kernel_size: int=1, stride: int=1, padding: int=0, fpn_interp_model: str='bilinear', fuse_type: str='sum', fpn_top_down_levels: Optional[List[int]]=None): + super().__init__() + self.position_encoding = position_encoding + self.convs = nn.ModuleList() + self.backbone_channel_list = backbone_channel_list + for dim in backbone_channel_list: + current = nn.Sequential() + current.add_module('conv', nn.Conv2d(in_channels=dim, out_channels=d_model, kernel_size=kernel_size, stride=stride, padding=padding)) + self.convs.append(current) + self.fpn_interp_model = fpn_interp_model + assert fuse_type in ['sum', 'avg'] + self.fuse_type = fuse_type + if fpn_top_down_levels is None: + fpn_top_down_levels = range(len(self.convs)) + self.fpn_top_down_levels = list(fpn_top_down_levels) + + def forward(self, xs: List[torch.Tensor]): + out = [None] * len(self.convs) + pos = [None] * len(self.convs) + assert len(xs) == len(self.convs) + prev_features = None + n = len(self.convs) - 1 + for i in range(n, -1, -1): + x = xs[i] + lateral_features = self.convs[n - i](x) + if i in self.fpn_top_down_levels and prev_features is not None: + top_down_features = F.interpolate(prev_features.to(dtype=torch.float32), scale_factor=2.0, mode=self.fpn_interp_model, align_corners=None if self.fpn_interp_model == 'nearest' else False, antialias=False) + prev_features = lateral_features + top_down_features + if self.fuse_type == 'avg': + prev_features /= 2 + else: + prev_features = lateral_features + x_out = prev_features + out[i] = x_out + pos[i] = self.position_encoding(x_out).to(x_out.dtype) + return (out, pos) + +# File: segment-anything-2-coreml-conversion/sam2/modeling/backbones/utils.py +"""""" +from typing import Tuple +import torch +import torch.nn as nn +import torch.nn.functional as F + +def window_partition(x, window_size): + (B, H, W, C) = x.shape + pad_h = (window_size - H % window_size) % window_size + pad_w = (window_size - W % window_size) % window_size + if pad_h > 0 or pad_w > 0: + x = F.pad(x, (0, 0, 0, pad_w, 0, pad_h)) + (Hp, Wp) = (H + pad_h, W + pad_w) + x = x.view(B, Hp // window_size, window_size, Wp // window_size, window_size, C) + windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C) + return (windows, (Hp, Wp)) + +def window_unpartition(windows, window_size, pad_hw, hw): + (Hp, Wp) = pad_hw + (H, W) = hw + B = windows.shape[0] // (Hp * Wp // window_size // window_size) + x = windows.view(B, Hp // window_size, Wp // window_size, window_size, window_size, -1) + x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, Hp, Wp, -1) + if Hp > H or Wp > W: + x = x[:, :H, :W, :].contiguous() + return x + +class PatchEmbed(nn.Module): + + def __init__(self, kernel_size: Tuple[int, ...]=(7, 7), stride: Tuple[int, ...]=(4, 4), padding: Tuple[int, ...]=(3, 3), in_chans: int=3, embed_dim: int=768): + super().__init__() + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=kernel_size, stride=stride, padding=padding) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.proj(x) + x = x.permute(0, 2, 3, 1) + return x + +# File: segment-anything-2-coreml-conversion/sam2/modeling/memory_attention.py +from typing import Optional +import torch +from torch import nn, Tensor +from sam2.modeling.sam.transformer import RoPEAttention +from sam2.modeling.sam2_utils import get_activation_fn, get_clones + +class MemoryAttentionLayer(nn.Module): + + def __init__(self, activation: str, cross_attention: nn.Module, d_model: int, dim_feedforward: int, dropout: float, pos_enc_at_attn: bool, pos_enc_at_cross_attn_keys: bool, pos_enc_at_cross_attn_queries: bool, self_attention: nn.Module): + super().__init__() + self.d_model = d_model + self.dim_feedforward = dim_feedforward + self.dropout_value = dropout + self.self_attn = self_attention + self.cross_attn_image = cross_attention + self.linear1 = nn.Linear(d_model, dim_feedforward) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + self.norm1 = nn.LayerNorm(d_model) + self.norm2 = nn.LayerNorm(d_model) + self.norm3 = nn.LayerNorm(d_model) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + self.dropout3 = nn.Dropout(dropout) + self.activation_str = activation + self.activation = get_activation_fn(activation) + self.pos_enc_at_attn = pos_enc_at_attn + self.pos_enc_at_cross_attn_queries = pos_enc_at_cross_attn_queries + self.pos_enc_at_cross_attn_keys = pos_enc_at_cross_attn_keys + + def _forward_sa(self, tgt, query_pos): + tgt2 = self.norm1(tgt) + q = k = tgt2 + query_pos if self.pos_enc_at_attn else tgt2 + tgt2 = self.self_attn(q, k, v=tgt2) + tgt = tgt + self.dropout1(tgt2) + return tgt + + def _forward_ca(self, tgt, memory, query_pos, pos, num_k_exclude_rope=0): + kwds = {} + if num_k_exclude_rope > 0: + assert isinstance(self.cross_attn_image, RoPEAttention) + kwds = {'num_k_exclude_rope': num_k_exclude_rope} + tgt2 = self.norm2(tgt) + tgt2 = self.cross_attn_image(q=tgt2 + query_pos if self.pos_enc_at_cross_attn_queries else tgt2, k=memory + pos if self.pos_enc_at_cross_attn_keys else memory, v=memory, **kwds) + tgt = tgt + self.dropout2(tgt2) + return tgt + + def forward(self, tgt, memory, pos: Optional[Tensor]=None, query_pos: Optional[Tensor]=None, num_k_exclude_rope: int=0) -> torch.Tensor: + tgt = self._forward_sa(tgt, query_pos) + tgt = self._forward_ca(tgt, memory, query_pos, pos, num_k_exclude_rope) + tgt2 = self.norm3(tgt) + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2)))) + tgt = tgt + self.dropout3(tgt2) + return tgt + +class MemoryAttention(nn.Module): + + def __init__(self, d_model: int, pos_enc_at_input: bool, layer: nn.Module, num_layers: int, batch_first: bool=True): + super().__init__() + self.d_model = d_model + self.layers = get_clones(layer, num_layers) + self.num_layers = num_layers + self.norm = nn.LayerNorm(d_model) + self.pos_enc_at_input = pos_enc_at_input + self.batch_first = batch_first + + def forward(self, curr: torch.Tensor, memory: torch.Tensor, curr_pos: Optional[Tensor]=None, memory_pos: Optional[Tensor]=None, num_obj_ptr_tokens: int=0): + if isinstance(curr, list): + assert isinstance(curr_pos, list) + assert len(curr) == len(curr_pos) == 1 + (curr, curr_pos) = (curr[0], curr_pos[0]) + assert curr.shape[1] == memory.shape[1], 'Batch size must be the same for curr and memory' + output = curr + if self.pos_enc_at_input and curr_pos is not None: + output = output + 0.1 * curr_pos + if self.batch_first: + output = output.transpose(0, 1) + curr_pos = curr_pos.transpose(0, 1) + memory = memory.transpose(0, 1) + memory_pos = memory_pos.transpose(0, 1) + for layer in self.layers: + kwds = {} + if isinstance(layer.cross_attn_image, RoPEAttention): + kwds = {'num_k_exclude_rope': num_obj_ptr_tokens} + output = layer(tgt=output, memory=memory, pos=memory_pos, query_pos=curr_pos, **kwds) + normed_output = self.norm(output) + if self.batch_first: + normed_output = normed_output.transpose(0, 1) + curr_pos = curr_pos.transpose(0, 1) + return normed_output + +# File: segment-anything-2-coreml-conversion/sam2/modeling/memory_encoder.py +import math +from typing import Tuple +import torch +import torch.nn as nn +import torch.nn.functional as F +from sam2.modeling.sam2_utils import DropPath, get_clones, LayerNorm2d + +class MaskDownSampler(nn.Module): + + def __init__(self, embed_dim=256, kernel_size=4, stride=4, padding=0, total_stride=16, activation=nn.GELU): + super().__init__() + num_layers = int(math.log2(total_stride) // math.log2(stride)) + assert stride ** num_layers == total_stride + self.encoder = nn.Sequential() + (mask_in_chans, mask_out_chans) = (1, 1) + for _ in range(num_layers): + mask_out_chans = mask_in_chans * stride ** 2 + self.encoder.append(nn.Conv2d(mask_in_chans, mask_out_chans, kernel_size=kernel_size, stride=stride, padding=padding)) + self.encoder.append(LayerNorm2d(mask_out_chans)) + self.encoder.append(activation()) + mask_in_chans = mask_out_chans + self.encoder.append(nn.Conv2d(mask_out_chans, embed_dim, kernel_size=1)) + + def forward(self, x): + return self.encoder(x) + +class CXBlock(nn.Module): + + def __init__(self, dim, kernel_size=7, padding=3, drop_path=0.0, layer_scale_init_value=1e-06, use_dwconv=True): + super().__init__() + self.dwconv = nn.Conv2d(dim, dim, kernel_size=kernel_size, padding=padding, groups=dim if use_dwconv else 1) + self.norm = LayerNorm2d(dim, eps=1e-06) + self.pwconv1 = nn.Linear(dim, 4 * dim) + self.act = nn.GELU() + self.pwconv2 = nn.Linear(4 * dim, dim) + self.gamma = nn.Parameter(layer_scale_init_value * torch.ones(dim), requires_grad=True) if layer_scale_init_value > 0 else None + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + def forward(self, x): + input = x + x = self.dwconv(x) + x = self.norm(x) + x = x.permute(0, 2, 3, 1) + x = self.pwconv1(x) + x = self.act(x) + x = self.pwconv2(x) + if self.gamma is not None: + x = self.gamma * x + x = x.permute(0, 3, 1, 2) + x = input + self.drop_path(x) + return x + +class Fuser(nn.Module): + + def __init__(self, layer, num_layers, dim=None, input_projection=False): + super().__init__() + self.proj = nn.Identity() + self.layers = get_clones(layer, num_layers) + if input_projection: + assert dim is not None + self.proj = nn.Conv2d(dim, dim, kernel_size=1) + + def forward(self, x): + x = self.proj(x) + for layer in self.layers: + x = layer(x) + return x + +class MemoryEncoder(nn.Module): + + def __init__(self, out_dim, mask_downsampler, fuser, position_encoding, in_dim=256): + super().__init__() + self.mask_downsampler = mask_downsampler + self.pix_feat_proj = nn.Conv2d(in_dim, in_dim, kernel_size=1) + self.fuser = fuser + self.position_encoding = position_encoding + self.out_proj = nn.Identity() + if out_dim != in_dim: + self.out_proj = nn.Conv2d(in_dim, out_dim, kernel_size=1) + + def forward(self, pix_feat: torch.Tensor, masks: torch.Tensor, skip_mask_sigmoid: bool=False) -> Tuple[torch.Tensor, torch.Tensor]: + if not skip_mask_sigmoid: + masks = F.sigmoid(masks) + masks = self.mask_downsampler(masks) + pix_feat = pix_feat.to(masks.device) + x = self.pix_feat_proj(pix_feat) + x = x + masks + x = self.fuser(x) + x = self.out_proj(x) + pos = self.position_encoding(x).to(x.dtype) + return {'vision_features': x, 'vision_pos_enc': [pos]} + +# File: segment-anything-2-coreml-conversion/sam2/modeling/position_encoding.py +import math +from typing import Any, Optional, Tuple +import numpy as np +import torch +from torch import nn + +class PositionEmbeddingSine(nn.Module): + + def __init__(self, num_pos_feats, temperature: int=10000, normalize: bool=True, scale: Optional[float]=None): + super().__init__() + assert num_pos_feats % 2 == 0, 'Expecting even model width' + self.num_pos_feats = num_pos_feats // 2 + self.temperature = temperature + self.normalize = normalize + if scale is not None and normalize is False: + raise ValueError('normalize should be True if scale is passed') + if scale is None: + scale = 2 * math.pi + self.scale = scale + self.cache = {} + + def _encode_xy(self, x, y): + assert len(x) == len(y) and x.ndim == y.ndim == 1 + x_embed = x * self.scale + y_embed = y * self.scale + dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device) + dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats) + pos_x = x_embed[:, None] / dim_t + pos_y = y_embed[:, None] / dim_t + pos_x = torch.stack((pos_x[:, 0::2].sin(), pos_x[:, 1::2].cos()), dim=2).flatten(1) + pos_y = torch.stack((pos_y[:, 0::2].sin(), pos_y[:, 1::2].cos()), dim=2).flatten(1) + return (pos_x, pos_y) + + @torch.no_grad() + def encode_boxes(self, x, y, w, h): + (pos_x, pos_y) = self._encode_xy(x, y) + pos = torch.cat((pos_y, pos_x, h[:, None], w[:, None]), dim=1) + return pos + encode = encode_boxes + + @torch.no_grad() + def encode_points(self, x, y, labels): + ((bx, nx), (by, ny), (bl, nl)) = (x.shape, y.shape, labels.shape) + assert bx == by and nx == ny and (bx == bl) and (nx == nl) + (pos_x, pos_y) = self._encode_xy(x.flatten(), y.flatten()) + (pos_x, pos_y) = (pos_x.reshape(bx, nx, -1), pos_y.reshape(by, ny, -1)) + pos = torch.cat((pos_y, pos_x, labels[:, :, None]), dim=2) + return pos + + @torch.no_grad() + def forward(self, x: torch.Tensor): + cache_key = (x.shape[-2], x.shape[-1]) + if cache_key in self.cache: + return self.cache[cache_key][None].repeat(x.shape[0], 1, 1, 1) + y_embed = torch.arange(1, x.shape[-2] + 1, dtype=torch.float32, device=x.device).view(1, -1, 1).repeat(x.shape[0], 1, x.shape[-1]) + x_embed = torch.arange(1, x.shape[-1] + 1, dtype=torch.float32, device=x.device).view(1, 1, -1).repeat(x.shape[0], x.shape[-2], 1) + if self.normalize: + eps = 1e-06 + y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale + x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale + dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device) + dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats) + pos_x = x_embed[:, :, :, None] / dim_t + pos_y = y_embed[:, :, :, None] / dim_t + pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3) + pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3) + pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) + self.cache[cache_key] = pos[0] + return pos + +class PositionEmbeddingRandom(nn.Module): + + def __init__(self, num_pos_feats: int=64, scale: Optional[float]=None) -> None: + super().__init__() + if scale is None or scale <= 0.0: + scale = 1.0 + self.register_buffer('positional_encoding_gaussian_matrix', scale * torch.randn((2, num_pos_feats))) + + def _pe_encoding(self, coords: torch.Tensor) -> torch.Tensor: + coords = 2 * coords - 1 + coords = coords @ self.positional_encoding_gaussian_matrix + coords = 2 * np.pi * coords + return torch.cat([torch.sin(coords), torch.cos(coords)], dim=-1) + + def forward(self, size: Tuple[int, int]) -> torch.Tensor: + (h, w) = size + device: Any = self.positional_encoding_gaussian_matrix.device + grid = torch.ones((h, w), device=device, dtype=torch.float32) + y_embed = grid.cumsum(dim=0) - 0.5 + x_embed = grid.cumsum(dim=1) - 0.5 + y_embed = y_embed / h + x_embed = x_embed / w + pe = self._pe_encoding(torch.stack([x_embed, y_embed], dim=-1)) + return pe.permute(2, 0, 1) + + def forward_with_coords(self, coords_input: torch.Tensor, image_size: Tuple[int, int]) -> torch.Tensor: + coords = coords_input.clone() + coords[:, :, 0] = coords[:, :, 0] / image_size[1] + coords[:, :, 1] = coords[:, :, 1] / image_size[0] + return self._pe_encoding(coords.to(torch.float)) + +def init_t_xy(end_x: int, end_y: int): + t = torch.arange(end_x * end_y, dtype=torch.float32) + t_x = (t % end_x).float() + t_y = torch.div(t, end_x, rounding_mode='floor').float() + return (t_x, t_y) + +def compute_axial_cis(dim: int, end_x: int, end_y: int, theta: float=10000.0): + freqs_x = 1.0 / theta ** (torch.arange(0, dim, 4)[:dim // 4].float() / dim) + freqs_y = 1.0 / theta ** (torch.arange(0, dim, 4)[:dim // 4].float() / dim) + (t_x, t_y) = init_t_xy(end_x, end_y) + freqs_x = torch.outer(t_x, freqs_x) + freqs_y = torch.outer(t_y, freqs_y) + freqs_cis_x = torch.polar(torch.ones_like(freqs_x), freqs_x) + freqs_cis_y = torch.polar(torch.ones_like(freqs_y), freqs_y) + return torch.cat([freqs_cis_x, freqs_cis_y], dim=-1) + +def reshape_for_broadcast(freqs_cis: torch.Tensor, x: torch.Tensor): + ndim = x.ndim + assert 0 <= 1 < ndim + assert freqs_cis.shape == (x.shape[-2], x.shape[-1]) + shape = [d if i >= ndim - 2 else 1 for (i, d) in enumerate(x.shape)] + return freqs_cis.view(*shape) + +def apply_rotary_enc(xq: torch.Tensor, xk: torch.Tensor, freqs_cis: torch.Tensor, repeat_freqs_k: bool=False): + xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2)) + xk_ = torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2)) if xk.shape[-2] != 0 else None + freqs_cis = reshape_for_broadcast(freqs_cis, xq_) + xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(3) + if xk_ is None: + return (xq_out.type_as(xq).to(xq.device), xk) + if repeat_freqs_k: + r = xk_.shape[-2] // xq_.shape[-2] + if freqs_cis.is_cuda: + freqs_cis = freqs_cis.repeat(*[1] * (freqs_cis.ndim - 2), r, 1) + else: + freqs_cis = freqs_cis.unsqueeze(2).expand(-1, -1, r, -1, -1).flatten(2, 3) + xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(3) + return (xq_out.type_as(xq).to(xq.device), xk_out.type_as(xk).to(xk.device)) + +# File: segment-anything-2-coreml-conversion/sam2/modeling/sam/mask_decoder.py +from typing import List, Optional, Tuple, Type +import torch +from torch import nn +from sam2.modeling.sam2_utils import LayerNorm2d, MLP + +class MaskDecoder(nn.Module): + + def __init__(self, *, transformer_dim: int, transformer: nn.Module, num_multimask_outputs: int=3, activation: Type[nn.Module]=nn.GELU, iou_head_depth: int=3, iou_head_hidden_dim: int=256, use_high_res_features: bool=False, iou_prediction_use_sigmoid=False, dynamic_multimask_via_stability=False, dynamic_multimask_stability_delta=0.05, dynamic_multimask_stability_thresh=0.98, pred_obj_scores: bool=False, pred_obj_scores_mlp: bool=False, use_multimask_token_for_obj_ptr: bool=False) -> None: + super().__init__() + self.transformer_dim = transformer_dim + self.transformer = transformer + self.num_multimask_outputs = num_multimask_outputs + self.iou_token = nn.Embedding(1, transformer_dim) + self.num_mask_tokens = num_multimask_outputs + 1 + self.mask_tokens = nn.Embedding(self.num_mask_tokens, transformer_dim) + self.pred_obj_scores = pred_obj_scores + if self.pred_obj_scores: + self.obj_score_token = nn.Embedding(1, transformer_dim) + self.use_multimask_token_for_obj_ptr = use_multimask_token_for_obj_ptr + self.output_upscaling = nn.Sequential(nn.ConvTranspose2d(transformer_dim, transformer_dim // 4, kernel_size=2, stride=2), LayerNorm2d(transformer_dim // 4), activation(), nn.ConvTranspose2d(transformer_dim // 4, transformer_dim // 8, kernel_size=2, stride=2), activation()) + self.use_high_res_features = use_high_res_features + if use_high_res_features: + self.conv_s0 = nn.Conv2d(transformer_dim, transformer_dim // 8, kernel_size=1, stride=1) + self.conv_s1 = nn.Conv2d(transformer_dim, transformer_dim // 4, kernel_size=1, stride=1) + self.output_hypernetworks_mlps = nn.ModuleList([MLP(transformer_dim, transformer_dim, transformer_dim // 8, 3) for i in range(self.num_mask_tokens)]) + self.iou_prediction_head = MLP(transformer_dim, iou_head_hidden_dim, self.num_mask_tokens, iou_head_depth, sigmoid_output=iou_prediction_use_sigmoid) + if self.pred_obj_scores: + self.pred_obj_score_head = nn.Linear(transformer_dim, 1) + if pred_obj_scores_mlp: + self.pred_obj_score_head = MLP(transformer_dim, transformer_dim, 1, 3) + self.dynamic_multimask_via_stability = dynamic_multimask_via_stability + self.dynamic_multimask_stability_delta = dynamic_multimask_stability_delta + self.dynamic_multimask_stability_thresh = dynamic_multimask_stability_thresh + + def forward(self, image_embeddings: torch.Tensor, image_pe: torch.Tensor, sparse_prompt_embeddings: torch.Tensor, dense_prompt_embeddings: torch.Tensor, multimask_output: bool, repeat_image: bool, high_res_features: Optional[List[torch.Tensor]]=None) -> Tuple[torch.Tensor, torch.Tensor]: + (masks, iou_pred, mask_tokens_out, object_score_logits) = self.predict_masks(image_embeddings=image_embeddings, image_pe=image_pe, sparse_prompt_embeddings=sparse_prompt_embeddings, dense_prompt_embeddings=dense_prompt_embeddings, repeat_image=repeat_image, high_res_features=high_res_features) + if multimask_output: + masks = masks[:, 1:, :, :] + iou_pred = iou_pred[:, 1:] + elif self.dynamic_multimask_via_stability and (not self.training): + (masks, iou_pred) = self._dynamic_multimask_via_stability(masks, iou_pred) + else: + masks = masks[:, 0:1, :, :] + iou_pred = iou_pred[:, 0:1] + if multimask_output and self.use_multimask_token_for_obj_ptr: + sam_tokens_out = mask_tokens_out[:, 1:] + else: + sam_tokens_out = mask_tokens_out[:, 0:1] + return (masks, iou_pred, sam_tokens_out, object_score_logits) + + def predict_masks(self, image_embeddings: torch.Tensor, image_pe: torch.Tensor, sparse_prompt_embeddings: torch.Tensor, dense_prompt_embeddings: torch.Tensor, repeat_image: bool, high_res_features: Optional[List[torch.Tensor]]=None) -> Tuple[torch.Tensor, torch.Tensor]: + s = 0 + if self.pred_obj_scores: + output_tokens = torch.cat([self.obj_score_token.weight, self.iou_token.weight, self.mask_tokens.weight], dim=0) + s = 1 + else: + output_tokens = torch.cat([self.iou_token.weight, self.mask_tokens.weight], dim=0) + output_tokens = output_tokens.unsqueeze(0).expand(sparse_prompt_embeddings.size(0), -1, -1) + tokens = torch.cat((output_tokens, sparse_prompt_embeddings), dim=1) + if repeat_image: + src = torch.repeat_interleave(image_embeddings, tokens.shape[0], dim=0) + else: + assert image_embeddings.shape[0] == tokens.shape[0] + src = image_embeddings + src = src + dense_prompt_embeddings + assert image_pe.size(0) == 1, 'image_pe should have size 1 in batch dim (from `get_dense_pe()`)' + pos_src = torch.repeat_interleave(image_pe, tokens.shape[0], dim=0) + (b, c, h, w) = src.shape + (hs, src) = self.transformer(src, pos_src, tokens) + iou_token_out = hs[:, s, :] + mask_tokens_out = hs[:, s + 1:s + 1 + self.num_mask_tokens, :] + src = src.transpose(1, 2).view(b, c, h, w) + if not self.use_high_res_features: + upscaled_embedding = self.output_upscaling(src) + else: + (dc1, ln1, act1, dc2, act2) = self.output_upscaling + (feat_s0, feat_s1) = high_res_features + upscaled_embedding = act1(ln1(dc1(src) + feat_s1)) + upscaled_embedding = act2(dc2(upscaled_embedding) + feat_s0) + hyper_in_list: List[torch.Tensor] = [] + for i in range(self.num_mask_tokens): + hyper_in_list.append(self.output_hypernetworks_mlps[i](mask_tokens_out[:, i, :])) + hyper_in = torch.stack(hyper_in_list, dim=1) + (b, c, h, w) = upscaled_embedding.shape + masks = (hyper_in @ upscaled_embedding.view(b, c, h * w)).view(b, -1, h, w) + iou_pred = self.iou_prediction_head(iou_token_out) + if self.pred_obj_scores: + assert s == 1 + object_score_logits = self.pred_obj_score_head(hs[:, 0, :]) + else: + object_score_logits = 10.0 * iou_pred.new_ones(iou_pred.shape[0], 1) + return (masks, iou_pred, mask_tokens_out, object_score_logits) + + def _get_stability_scores(self, mask_logits): + mask_logits = mask_logits.flatten(-2) + stability_delta = self.dynamic_multimask_stability_delta + area_i = torch.sum(mask_logits > stability_delta, dim=-1).float() + area_u = torch.sum(mask_logits > -stability_delta, dim=-1).float() + stability_scores = torch.where(area_u > 0, area_i / area_u, 1.0) + return stability_scores + + def _dynamic_multimask_via_stability(self, all_mask_logits, all_iou_scores): + multimask_logits = all_mask_logits[:, 1:, :, :] + multimask_iou_scores = all_iou_scores[:, 1:] + best_scores_inds = torch.argmax(multimask_iou_scores, dim=-1) + batch_inds = torch.arange(multimask_iou_scores.size(0), device=all_iou_scores.device) + best_multimask_logits = multimask_logits[batch_inds, best_scores_inds] + best_multimask_logits = best_multimask_logits.unsqueeze(1) + best_multimask_iou_scores = multimask_iou_scores[batch_inds, best_scores_inds] + best_multimask_iou_scores = best_multimask_iou_scores.unsqueeze(1) + singlemask_logits = all_mask_logits[:, 0:1, :, :] + singlemask_iou_scores = all_iou_scores[:, 0:1] + stability_scores = self._get_stability_scores(singlemask_logits) + is_stable = stability_scores >= self.dynamic_multimask_stability_thresh + mask_logits_out = torch.where(is_stable[..., None, None].expand_as(singlemask_logits), singlemask_logits, best_multimask_logits) + iou_scores_out = torch.where(is_stable.expand_as(singlemask_iou_scores), singlemask_iou_scores, best_multimask_iou_scores) + return (mask_logits_out, iou_scores_out) + +# File: segment-anything-2-coreml-conversion/sam2/modeling/sam/prompt_encoder.py +from typing import Optional, Tuple, Type +import torch +from torch import nn +from sam2.modeling.position_encoding import PositionEmbeddingRandom +from sam2.modeling.sam2_utils import LayerNorm2d + +class PromptEncoder(nn.Module): + + def __init__(self, embed_dim: int, image_embedding_size: Tuple[int, int], input_image_size: Tuple[int, int], mask_in_chans: int, activation: Type[nn.Module]=nn.GELU) -> None: + super().__init__() + self.embed_dim = embed_dim + self.input_image_size = input_image_size + self.image_embedding_size = image_embedding_size + self.pe_layer = PositionEmbeddingRandom(embed_dim // 2) + self.num_point_embeddings: int = 4 + point_embeddings = [nn.Embedding(1, embed_dim) for i in range(self.num_point_embeddings)] + self.point_embeddings = nn.ModuleList(point_embeddings) + self.not_a_point_embed = nn.Embedding(1, embed_dim) + self.mask_input_size = (4 * image_embedding_size[0], 4 * image_embedding_size[1]) + self.mask_downscaling = nn.Sequential(nn.Conv2d(1, mask_in_chans // 4, kernel_size=2, stride=2), LayerNorm2d(mask_in_chans // 4), activation(), nn.Conv2d(mask_in_chans // 4, mask_in_chans, kernel_size=2, stride=2), LayerNorm2d(mask_in_chans), activation(), nn.Conv2d(mask_in_chans, embed_dim, kernel_size=1)) + self.no_mask_embed = nn.Embedding(1, embed_dim) + + def get_dense_pe(self) -> torch.Tensor: + return self.pe_layer(self.image_embedding_size).unsqueeze(0) + + def _embed_points(self, points: torch.Tensor, labels: torch.Tensor, pad: bool) -> torch.Tensor: + points = points + 0.5 + if pad: + padding_point = torch.zeros((points.shape[0], 1, 2), device=points.device) + padding_label = -torch.ones((labels.shape[0], 1), device=labels.device) + points = torch.cat([points, padding_point], dim=1) + labels = torch.cat([labels, padding_label], dim=1) + point_embedding = self.pe_layer.forward_with_coords(points, self.input_image_size) + mask_not_a_point = (labels == -1).float().unsqueeze(-1) + mask_label_0 = (labels == 0).float().unsqueeze(-1) + mask_label_1 = (labels == 1).float().unsqueeze(-1) + mask_label_2 = (labels == 2).float().unsqueeze(-1) + mask_label_3 = (labels == 3).float().unsqueeze(-1) + point_embedding = point_embedding * (1 - mask_not_a_point) + self.not_a_point_embed.weight * mask_not_a_point + self.point_embeddings[0].weight * mask_label_0 + self.point_embeddings[1].weight * mask_label_1 + self.point_embeddings[2].weight * mask_label_2 + self.point_embeddings[3].weight * mask_label_3 + return point_embedding + + def _embed_boxes(self, boxes: torch.Tensor) -> torch.Tensor: + boxes = boxes + 0.5 + coords = boxes.reshape(-1, 2, 2) + corner_embedding = self.pe_layer.forward_with_coords(coords, self.input_image_size) + corner_embedding[:, 0, :] += self.point_embeddings[2].weight + corner_embedding[:, 1, :] += self.point_embeddings[3].weight + return corner_embedding + + def _embed_masks(self, masks: torch.Tensor) -> torch.Tensor: + mask_embedding = self.mask_downscaling(masks) + return mask_embedding + + def _get_batch_size(self, points: Optional[Tuple[torch.Tensor, torch.Tensor]], boxes: Optional[torch.Tensor], masks: Optional[torch.Tensor]) -> int: + if points is not None: + return points[0].shape[0] + elif boxes is not None: + return boxes.shape[0] + elif masks is not None: + return masks.shape[0] + else: + return 1 + + def _get_device(self) -> torch.device: + return self.point_embeddings[0].weight.device + + def forward(self, points: Optional[Tuple[torch.Tensor, torch.Tensor]], boxes: Optional[torch.Tensor], masks: Optional[torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]: + bs = self._get_batch_size(points, boxes, masks) + sparse_embeddings = torch.empty((bs, 0, self.embed_dim), device=self._get_device()) + if points is not None: + (coords, labels) = points + point_embeddings = self._embed_points(coords, labels, pad=boxes is None) + sparse_embeddings = torch.cat([sparse_embeddings, point_embeddings], dim=1) + if boxes is not None: + box_embeddings = self._embed_boxes(boxes) + sparse_embeddings = torch.cat([sparse_embeddings, box_embeddings], dim=1) + if masks is not None: + dense_embeddings = self._embed_masks(masks) + else: + dense_embeddings = self.no_mask_embed.weight.reshape(1, -1, 1, 1).expand(bs, -1, self.image_embedding_size[0], self.image_embedding_size[1]) + return (sparse_embeddings, dense_embeddings) + + def points_only(self, points: Tuple[torch.Tensor, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]: + (coords, labels) = points + sparse_embeddings = self._embed_points(coords, labels, pad=True) + bs = points[0].shape[0] + dense_embeddings = self.no_mask_embed.weight.reshape(1, -1, 1, 1).expand(bs, -1, self.image_embedding_size[0], self.image_embedding_size[1]) + return (sparse_embeddings, dense_embeddings) + +# File: segment-anything-2-coreml-conversion/sam2/modeling/sam/transformer.py +import contextlib +import math +import warnings +from functools import partial +from typing import Tuple, Type +import torch +import torch.nn.functional as F +from torch import nn, Tensor +from sam2.modeling.position_encoding import apply_rotary_enc, compute_axial_cis +from sam2.modeling.sam2_utils import MLP +from sam2.utils.misc import get_sdpa_settings +warnings.simplefilter(action='ignore', category=FutureWarning) +(OLD_GPU, USE_FLASH_ATTN, MATH_KERNEL_ON) = get_sdpa_settings() +ALLOW_ALL_KERNELS = False + +def sdp_kernel_context(dropout_p): + if ALLOW_ALL_KERNELS: + return contextlib.nullcontext() + return torch.backends.cuda.sdp_kernel(enable_flash=USE_FLASH_ATTN, enable_math=OLD_GPU and dropout_p > 0.0 or MATH_KERNEL_ON, enable_mem_efficient=OLD_GPU) + +class TwoWayTransformer(nn.Module): + + def __init__(self, depth: int, embedding_dim: int, num_heads: int, mlp_dim: int, activation: Type[nn.Module]=nn.ReLU, attention_downsample_rate: int=2) -> None: + super().__init__() + self.depth = depth + self.embedding_dim = embedding_dim + self.num_heads = num_heads + self.mlp_dim = mlp_dim + self.layers = nn.ModuleList() + for i in range(depth): + self.layers.append(TwoWayAttentionBlock(embedding_dim=embedding_dim, num_heads=num_heads, mlp_dim=mlp_dim, activation=activation, attention_downsample_rate=attention_downsample_rate, skip_first_layer_pe=i == 0)) + self.final_attn_token_to_image = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate) + self.norm_final_attn = nn.LayerNorm(embedding_dim) + + def forward(self, image_embedding: Tensor, image_pe: Tensor, point_embedding: Tensor) -> Tuple[Tensor, Tensor]: + (bs, c, h, w) = image_embedding.shape + image_embedding = image_embedding.flatten(2).permute(0, 2, 1) + image_pe = image_pe.flatten(2).permute(0, 2, 1) + queries = point_embedding + keys = image_embedding + for layer in self.layers: + (queries, keys) = layer(queries=queries, keys=keys, query_pe=point_embedding, key_pe=image_pe) + q = queries + point_embedding + k = keys + image_pe + attn_out = self.final_attn_token_to_image(q=q, k=k, v=keys) + queries = queries + attn_out + queries = self.norm_final_attn(queries) + return (queries, keys) + +class TwoWayAttentionBlock(nn.Module): + + def __init__(self, embedding_dim: int, num_heads: int, mlp_dim: int=2048, activation: Type[nn.Module]=nn.ReLU, attention_downsample_rate: int=2, skip_first_layer_pe: bool=False) -> None: + super().__init__() + self.self_attn = Attention(embedding_dim, num_heads) + self.norm1 = nn.LayerNorm(embedding_dim) + self.cross_attn_token_to_image = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate) + self.norm2 = nn.LayerNorm(embedding_dim) + self.mlp = MLP(embedding_dim, mlp_dim, embedding_dim, num_layers=2, activation=activation) + self.norm3 = nn.LayerNorm(embedding_dim) + self.norm4 = nn.LayerNorm(embedding_dim) + self.cross_attn_image_to_token = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate) + self.skip_first_layer_pe = skip_first_layer_pe + + def forward(self, queries: Tensor, keys: Tensor, query_pe: Tensor, key_pe: Tensor) -> Tuple[Tensor, Tensor]: + if self.skip_first_layer_pe: + queries = self.self_attn(q=queries, k=queries, v=queries) + else: + q = queries + query_pe + attn_out = self.self_attn(q=q, k=q, v=queries) + queries = queries + attn_out + queries = self.norm1(queries) + q = queries + query_pe + k = keys + key_pe + attn_out = self.cross_attn_token_to_image(q=q, k=k, v=keys) + queries = queries + attn_out + queries = self.norm2(queries) + mlp_out = self.mlp(queries) + queries = queries + mlp_out + queries = self.norm3(queries) + q = queries + query_pe + k = keys + key_pe + attn_out = self.cross_attn_image_to_token(q=k, k=q, v=queries) + keys = keys + attn_out + keys = self.norm4(keys) + return (queries, keys) + +class Attention(nn.Module): + + def __init__(self, embedding_dim: int, num_heads: int, downsample_rate: int=1, dropout: float=0.0, kv_in_dim: int=None) -> None: + super().__init__() + self.embedding_dim = embedding_dim + self.kv_in_dim = kv_in_dim if kv_in_dim is not None else embedding_dim + self.internal_dim = embedding_dim // downsample_rate + self.num_heads = num_heads + assert self.internal_dim % num_heads == 0, 'num_heads must divide embedding_dim.' + self.q_proj = nn.Linear(embedding_dim, self.internal_dim) + self.k_proj = nn.Linear(self.kv_in_dim, self.internal_dim) + self.v_proj = nn.Linear(self.kv_in_dim, self.internal_dim) + self.out_proj = nn.Linear(self.internal_dim, embedding_dim) + self.dropout_p = dropout + + def _separate_heads(self, x: Tensor, num_heads: int) -> Tensor: + (b, n, c) = x.shape + x = x.reshape(b, n, num_heads, c // num_heads) + return x.transpose(1, 2) + + def _recombine_heads(self, x: Tensor) -> Tensor: + (b, n_heads, n_tokens, c_per_head) = x.shape + x = x.transpose(1, 2) + return x.reshape(b, n_tokens, n_heads * c_per_head) + + def forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor: + q = self.q_proj(q) + k = self.k_proj(k) + v = self.v_proj(v) + q = self._separate_heads(q, self.num_heads) + k = self._separate_heads(k, self.num_heads) + v = self._separate_heads(v, self.num_heads) + dropout_p = self.dropout_p if self.training else 0.0 + try: + with sdp_kernel_context(dropout_p): + out = F.scaled_dot_product_attention(q, k, v, dropout_p=dropout_p) + except Exception as e: + warnings.warn(f'Flash Attention kernel failed due to: {e}\nFalling back to all available kernels for scaled_dot_product_attention (which may have a slower speed).', category=UserWarning, stacklevel=2) + global ALLOW_ALL_KERNELS + ALLOW_ALL_KERNELS = True + out = F.scaled_dot_product_attention(q, k, v, dropout_p=dropout_p) + out = self._recombine_heads(out) + out = self.out_proj(out) + return out + +class RoPEAttention(Attention): + + def __init__(self, *args, rope_theta=10000.0, rope_k_repeat=False, feat_sizes=(32, 32), **kwargs): + super().__init__(*args, **kwargs) + self.compute_cis = partial(compute_axial_cis, dim=self.internal_dim // self.num_heads, theta=rope_theta) + freqs_cis = self.compute_cis(end_x=feat_sizes[0], end_y=feat_sizes[1]) + self.freqs_cis = freqs_cis + self.rope_k_repeat = rope_k_repeat + + def forward(self, q: Tensor, k: Tensor, v: Tensor, num_k_exclude_rope: int=0) -> Tensor: + q = self.q_proj(q) + k = self.k_proj(k) + v = self.v_proj(v) + q = self._separate_heads(q, self.num_heads) + k = self._separate_heads(k, self.num_heads) + v = self._separate_heads(v, self.num_heads) + w = h = math.sqrt(q.shape[-2]) + self.freqs_cis = self.freqs_cis.to(q.device) + if self.freqs_cis.shape[0] != q.shape[-2]: + self.freqs_cis = self.compute_cis(end_x=w, end_y=h).to(q.device) + if q.shape[-2] != k.shape[-2]: + assert self.rope_k_repeat + num_k_rope = k.size(-2) - num_k_exclude_rope + (q, k[:, :, :num_k_rope]) = apply_rotary_enc(q, k[:, :, :num_k_rope], freqs_cis=self.freqs_cis, repeat_freqs_k=self.rope_k_repeat) + dropout_p = self.dropout_p if self.training else 0.0 + try: + with sdp_kernel_context(dropout_p): + out = F.scaled_dot_product_attention(q, k, v, dropout_p=dropout_p) + except Exception as e: + warnings.warn(f'Flash Attention kernel failed due to: {e}\nFalling back to all available kernels for scaled_dot_product_attention (which may have a slower speed).', category=UserWarning, stacklevel=2) + global ALLOW_ALL_KERNELS + ALLOW_ALL_KERNELS = True + out = F.scaled_dot_product_attention(q, k, v, dropout_p=dropout_p) + out = self._recombine_heads(out) + out = self.out_proj(out) + return out + +# File: segment-anything-2-coreml-conversion/sam2/modeling/sam2_base.py +import torch +import torch.distributed +import torch.nn.functional as F +from torch.nn.init import trunc_normal_ +from sam2.modeling.sam.mask_decoder import MaskDecoder +from sam2.modeling.sam.prompt_encoder import PromptEncoder +from sam2.modeling.sam.transformer import TwoWayTransformer +from sam2.modeling.sam2_utils import get_1d_sine_pe, MLP, select_closest_cond_frames +NO_OBJ_SCORE = -1024.0 + +class SAM2Base(torch.nn.Module): + + def __init__(self, image_encoder, memory_attention, memory_encoder, num_maskmem=7, image_size=512, backbone_stride=16, sigmoid_scale_for_mem_enc=1.0, sigmoid_bias_for_mem_enc=0.0, binarize_mask_from_pts_for_mem_enc=False, use_mask_input_as_output_without_sam=False, max_cond_frames_in_attn=-1, directly_add_no_mem_embed=False, use_high_res_features_in_sam=False, multimask_output_in_sam=False, multimask_min_pt_num=1, multimask_max_pt_num=1, multimask_output_for_tracking=False, use_multimask_token_for_obj_ptr: bool=False, iou_prediction_use_sigmoid=False, memory_temporal_stride_for_eval=1, add_all_frames_to_correct_as_cond=False, non_overlap_masks_for_mem_enc=False, use_obj_ptrs_in_encoder=False, max_obj_ptrs_in_encoder=16, add_tpos_enc_to_obj_ptrs=True, proj_tpos_enc_in_obj_ptrs=False, only_obj_ptrs_in_the_past_for_eval=False, pred_obj_scores: bool=False, pred_obj_scores_mlp: bool=False, fixed_no_obj_ptr: bool=False, soft_no_obj_ptr: bool=False, use_mlp_for_obj_ptr_proj: bool=False, sam_mask_decoder_extra_args=None, compile_image_encoder: bool=False): + super().__init__() + self.image_encoder = image_encoder + self.use_high_res_features_in_sam = use_high_res_features_in_sam + self.num_feature_levels = 3 if use_high_res_features_in_sam else 1 + self.use_obj_ptrs_in_encoder = use_obj_ptrs_in_encoder + self.max_obj_ptrs_in_encoder = max_obj_ptrs_in_encoder + if use_obj_ptrs_in_encoder: + self.mask_downsample = torch.nn.Conv2d(1, 1, kernel_size=4, stride=4) + self.add_tpos_enc_to_obj_ptrs = add_tpos_enc_to_obj_ptrs + if proj_tpos_enc_in_obj_ptrs: + assert add_tpos_enc_to_obj_ptrs + self.proj_tpos_enc_in_obj_ptrs = proj_tpos_enc_in_obj_ptrs + self.only_obj_ptrs_in_the_past_for_eval = only_obj_ptrs_in_the_past_for_eval + self.memory_attention = memory_attention + self.hidden_dim = memory_attention.d_model + self.memory_encoder = memory_encoder + self.mem_dim = self.hidden_dim + if hasattr(self.memory_encoder, 'out_proj') and hasattr(self.memory_encoder.out_proj, 'weight'): + self.mem_dim = self.memory_encoder.out_proj.weight.shape[0] + self.num_maskmem = num_maskmem + self.maskmem_tpos_enc = torch.nn.Parameter(torch.zeros(num_maskmem, 1, 1, self.mem_dim)) + trunc_normal_(self.maskmem_tpos_enc, std=0.02) + self.no_mem_embed = torch.nn.Parameter(torch.zeros(1, 1, self.hidden_dim)) + self.no_mem_pos_enc = torch.nn.Parameter(torch.zeros(1, 1, self.hidden_dim)) + trunc_normal_(self.no_mem_embed, std=0.02) + trunc_normal_(self.no_mem_pos_enc, std=0.02) + self.directly_add_no_mem_embed = directly_add_no_mem_embed + self.sigmoid_scale_for_mem_enc = sigmoid_scale_for_mem_enc + self.sigmoid_bias_for_mem_enc = sigmoid_bias_for_mem_enc + self.binarize_mask_from_pts_for_mem_enc = binarize_mask_from_pts_for_mem_enc + self.non_overlap_masks_for_mem_enc = non_overlap_masks_for_mem_enc + self.memory_temporal_stride_for_eval = memory_temporal_stride_for_eval + self.use_mask_input_as_output_without_sam = use_mask_input_as_output_without_sam + self.multimask_output_in_sam = multimask_output_in_sam + self.multimask_min_pt_num = multimask_min_pt_num + self.multimask_max_pt_num = multimask_max_pt_num + self.multimask_output_for_tracking = multimask_output_for_tracking + self.use_multimask_token_for_obj_ptr = use_multimask_token_for_obj_ptr + self.iou_prediction_use_sigmoid = iou_prediction_use_sigmoid + self.image_size = image_size + self.backbone_stride = backbone_stride + self.sam_mask_decoder_extra_args = sam_mask_decoder_extra_args + self.pred_obj_scores = pred_obj_scores + self.pred_obj_scores_mlp = pred_obj_scores_mlp + self.fixed_no_obj_ptr = fixed_no_obj_ptr + self.soft_no_obj_ptr = soft_no_obj_ptr + if self.fixed_no_obj_ptr: + assert self.pred_obj_scores + assert self.use_obj_ptrs_in_encoder + if self.pred_obj_scores and self.use_obj_ptrs_in_encoder: + self.no_obj_ptr = torch.nn.Parameter(torch.zeros(1, self.hidden_dim)) + trunc_normal_(self.no_obj_ptr, std=0.02) + self.use_mlp_for_obj_ptr_proj = use_mlp_for_obj_ptr_proj + self._build_sam_heads() + self.add_all_frames_to_correct_as_cond = add_all_frames_to_correct_as_cond + self.max_cond_frames_in_attn = max_cond_frames_in_attn + if compile_image_encoder: + print('Image encoder compilation is enabled. First forward pass will be slow.') + self.image_encoder.forward = torch.compile(self.image_encoder.forward, mode='max-autotune', fullgraph=True, dynamic=False) + + @property + def device(self): + return next(self.parameters()).device + + def forward(self, *args, **kwargs): + raise NotImplementedError('Please use the corresponding methods in SAM2VideoPredictor for inference.See notebooks/video_predictor_example.ipynb for an example.') + + def _build_sam_heads(self): + self.sam_prompt_embed_dim = self.hidden_dim + self.sam_image_embedding_size = self.image_size // self.backbone_stride + self.sam_prompt_encoder = PromptEncoder(embed_dim=self.sam_prompt_embed_dim, image_embedding_size=(self.sam_image_embedding_size, self.sam_image_embedding_size), input_image_size=(self.image_size, self.image_size), mask_in_chans=16) + self.sam_mask_decoder = MaskDecoder(num_multimask_outputs=3, transformer=TwoWayTransformer(depth=2, embedding_dim=self.sam_prompt_embed_dim, mlp_dim=2048, num_heads=8), transformer_dim=self.sam_prompt_embed_dim, iou_head_depth=3, iou_head_hidden_dim=256, use_high_res_features=self.use_high_res_features_in_sam, iou_prediction_use_sigmoid=self.iou_prediction_use_sigmoid, pred_obj_scores=self.pred_obj_scores, pred_obj_scores_mlp=self.pred_obj_scores_mlp, use_multimask_token_for_obj_ptr=self.use_multimask_token_for_obj_ptr, **self.sam_mask_decoder_extra_args or {}) + if self.use_obj_ptrs_in_encoder: + self.obj_ptr_proj = torch.nn.Linear(self.hidden_dim, self.hidden_dim) + if self.use_mlp_for_obj_ptr_proj: + self.obj_ptr_proj = MLP(self.hidden_dim, self.hidden_dim, self.hidden_dim, 3) + else: + self.obj_ptr_proj = torch.nn.Identity() + if self.proj_tpos_enc_in_obj_ptrs: + self.obj_ptr_tpos_proj = torch.nn.Linear(self.hidden_dim, self.mem_dim) + else: + self.obj_ptr_tpos_proj = torch.nn.Identity() + + def _forward_sam_heads(self, backbone_features, point_inputs=None, mask_inputs=None, high_res_features=None, multimask_output=False): + B = backbone_features.size(0) + device = backbone_features.device + assert backbone_features.size(1) == self.sam_prompt_embed_dim + assert backbone_features.size(2) == self.sam_image_embedding_size + assert backbone_features.size(3) == self.sam_image_embedding_size + if point_inputs is not None: + sam_point_coords = point_inputs['point_coords'] + sam_point_labels = point_inputs['point_labels'] + assert sam_point_coords.size(0) == B and sam_point_labels.size(0) == B + else: + sam_point_coords = torch.zeros(B, 1, 2, device=device) + sam_point_labels = -torch.ones(B, 1, dtype=torch.int32, device=device) + if mask_inputs is not None: + assert len(mask_inputs.shape) == 4 and mask_inputs.shape[:2] == (B, 1) + if mask_inputs.shape[-2:] != self.sam_prompt_encoder.mask_input_size: + sam_mask_prompt = F.interpolate(mask_inputs.float(), size=self.sam_prompt_encoder.mask_input_size, align_corners=False, mode='bilinear', antialias=True) + else: + sam_mask_prompt = mask_inputs + else: + sam_mask_prompt = None + (sparse_embeddings, dense_embeddings) = self.sam_prompt_encoder(points=(sam_point_coords, sam_point_labels), boxes=None, masks=sam_mask_prompt) + (low_res_multimasks, ious, sam_output_tokens, object_score_logits) = self.sam_mask_decoder(image_embeddings=backbone_features, image_pe=self.sam_prompt_encoder.get_dense_pe(), sparse_prompt_embeddings=sparse_embeddings, dense_prompt_embeddings=dense_embeddings, multimask_output=multimask_output, repeat_image=False, high_res_features=high_res_features) + if self.pred_obj_scores: + is_obj_appearing = object_score_logits > 0 + low_res_multimasks = torch.where(is_obj_appearing[:, None, None], low_res_multimasks, NO_OBJ_SCORE) + low_res_multimasks = low_res_multimasks.float() + high_res_multimasks = F.interpolate(low_res_multimasks, size=(self.image_size, self.image_size), mode='bilinear', align_corners=False) + sam_output_token = sam_output_tokens[:, 0] + if multimask_output: + best_iou_inds = torch.argmax(ious, dim=-1) + batch_inds = torch.arange(B, device=device) + low_res_masks = low_res_multimasks[batch_inds, best_iou_inds].unsqueeze(1) + high_res_masks = high_res_multimasks[batch_inds, best_iou_inds].unsqueeze(1) + if sam_output_tokens.size(1) > 1: + sam_output_token = sam_output_tokens[batch_inds, best_iou_inds] + else: + (low_res_masks, high_res_masks) = (low_res_multimasks, high_res_multimasks) + obj_ptr = self.obj_ptr_proj(sam_output_token) + if self.pred_obj_scores: + if self.soft_no_obj_ptr: + assert not self.teacher_force_obj_scores_for_mem + lambda_is_obj_appearing = object_score_logits.sigmoid() + else: + lambda_is_obj_appearing = is_obj_appearing.float() + if self.fixed_no_obj_ptr: + obj_ptr = lambda_is_obj_appearing * obj_ptr + obj_ptr = obj_ptr + (1 - lambda_is_obj_appearing) * self.no_obj_ptr + return (low_res_multimasks, high_res_multimasks, ious, low_res_masks, high_res_masks, obj_ptr, object_score_logits) + + def _use_mask_as_output(self, backbone_features, high_res_features, mask_inputs): + (out_scale, out_bias) = (20.0, -10.0) + mask_inputs_float = mask_inputs.float() + high_res_masks = mask_inputs_float * out_scale + out_bias + low_res_masks = F.interpolate(high_res_masks, size=(high_res_masks.size(-2) // 4, high_res_masks.size(-1) // 4), align_corners=False, mode='bilinear', antialias=True) + ious = mask_inputs.new_ones(mask_inputs.size(0), 1).float() + if not self.use_obj_ptrs_in_encoder: + obj_ptr = torch.zeros(mask_inputs.size(0), self.hidden_dim, device=mask_inputs.device) + else: + (_, _, _, _, _, obj_ptr, _) = self._forward_sam_heads(backbone_features=backbone_features, mask_inputs=self.mask_downsample(mask_inputs_float), high_res_features=high_res_features) + is_obj_appearing = torch.any(mask_inputs.flatten(1).float() > 0.0, dim=1) + is_obj_appearing = is_obj_appearing[..., None] + lambda_is_obj_appearing = is_obj_appearing.float() + object_score_logits = out_scale * lambda_is_obj_appearing + out_bias + if self.pred_obj_scores: + if self.fixed_no_obj_ptr: + obj_ptr = lambda_is_obj_appearing * obj_ptr + obj_ptr = obj_ptr + (1 - lambda_is_obj_appearing) * self.no_obj_ptr + return (low_res_masks, high_res_masks, ious, low_res_masks, high_res_masks, obj_ptr, object_score_logits) + + def forward_image(self, img_batch: torch.Tensor): + backbone_out = self.image_encoder(img_batch) + if self.use_high_res_features_in_sam: + backbone_out['backbone_fpn'][0] = self.sam_mask_decoder.conv_s0(backbone_out['backbone_fpn'][0]) + backbone_out['backbone_fpn'][1] = self.sam_mask_decoder.conv_s1(backbone_out['backbone_fpn'][1]) + return backbone_out + + def _prepare_backbone_features(self, backbone_out): + backbone_out = backbone_out.copy() + assert len(backbone_out['backbone_fpn']) == len(backbone_out['vision_pos_enc']) + assert len(backbone_out['backbone_fpn']) >= self.num_feature_levels + feature_maps = backbone_out['backbone_fpn'][-self.num_feature_levels:] + vision_pos_embeds = backbone_out['vision_pos_enc'][-self.num_feature_levels:] + feat_sizes = [(x.shape[-2], x.shape[-1]) for x in vision_pos_embeds] + vision_feats = [x.flatten(2).permute(2, 0, 1) for x in feature_maps] + vision_pos_embeds = [x.flatten(2).permute(2, 0, 1) for x in vision_pos_embeds] + return (backbone_out, vision_feats, vision_pos_embeds, feat_sizes) + + def _prepare_memory_conditioned_features(self, frame_idx, is_init_cond_frame, current_vision_feats, current_vision_pos_embeds, feat_sizes, output_dict, num_frames, track_in_reverse=False): + B = current_vision_feats[-1].size(1) + C = self.hidden_dim + (H, W) = feat_sizes[-1] + device = current_vision_feats[-1].device + if self.num_maskmem == 0: + pix_feat = current_vision_feats[-1].permute(1, 2, 0).view(B, C, H, W) + return pix_feat + num_obj_ptr_tokens = 0 + if not is_init_cond_frame: + (to_cat_memory, to_cat_memory_pos_embed) = ([], []) + assert len(output_dict['cond_frame_outputs']) > 0 + cond_outputs = output_dict['cond_frame_outputs'] + (selected_cond_outputs, unselected_cond_outputs) = select_closest_cond_frames(frame_idx, cond_outputs, self.max_cond_frames_in_attn) + t_pos_and_prevs = [(0, out) for out in selected_cond_outputs.values()] + r = self.memory_temporal_stride_for_eval + for t_pos in range(1, self.num_maskmem): + t_rel = self.num_maskmem - t_pos + if t_rel == 1: + if not track_in_reverse: + prev_frame_idx = frame_idx - t_rel + else: + prev_frame_idx = frame_idx + t_rel + elif not track_in_reverse: + prev_frame_idx = (frame_idx - 2) // r * r + prev_frame_idx = prev_frame_idx - (t_rel - 2) * r + else: + prev_frame_idx = -(-(frame_idx + 2) // r) * r + prev_frame_idx = prev_frame_idx + (t_rel - 2) * r + out = output_dict['non_cond_frame_outputs'].get(prev_frame_idx, None) + if out is None: + out = unselected_cond_outputs.get(prev_frame_idx, None) + t_pos_and_prevs.append((t_pos, out)) + for (t_pos, prev) in t_pos_and_prevs: + if prev is None: + continue + feats = prev['maskmem_features'].to(device, non_blocking=True) + to_cat_memory.append(feats.flatten(2).permute(2, 0, 1)) + maskmem_enc = prev['maskmem_pos_enc'][-1].to(device) + maskmem_enc = maskmem_enc.flatten(2).permute(2, 0, 1) + maskmem_enc = maskmem_enc + self.maskmem_tpos_enc[self.num_maskmem - t_pos - 1] + to_cat_memory_pos_embed.append(maskmem_enc) + if self.use_obj_ptrs_in_encoder: + max_obj_ptrs_in_encoder = min(num_frames, self.max_obj_ptrs_in_encoder) + if not self.training and self.only_obj_ptrs_in_the_past_for_eval: + ptr_cond_outputs = {t: out for (t, out) in selected_cond_outputs.items() if (t >= frame_idx if track_in_reverse else t <= frame_idx)} + else: + ptr_cond_outputs = selected_cond_outputs + pos_and_ptrs = [(abs(frame_idx - t), out['obj_ptr']) for (t, out) in ptr_cond_outputs.items()] + for t_diff in range(1, max_obj_ptrs_in_encoder): + t = frame_idx + t_diff if track_in_reverse else frame_idx - t_diff + if t < 0 or (num_frames is not None and t >= num_frames): + break + out = output_dict['non_cond_frame_outputs'].get(t, unselected_cond_outputs.get(t, None)) + if out is not None: + pos_and_ptrs.append((t_diff, out['obj_ptr'])) + if len(pos_and_ptrs) > 0: + (pos_list, ptrs_list) = zip(*pos_and_ptrs) + obj_ptrs = torch.stack(ptrs_list, dim=0) + if self.add_tpos_enc_to_obj_ptrs: + t_diff_max = max_obj_ptrs_in_encoder - 1 + tpos_dim = C if self.proj_tpos_enc_in_obj_ptrs else self.mem_dim + obj_pos = torch.tensor(pos_list, device=device) + obj_pos = get_1d_sine_pe(obj_pos / t_diff_max, dim=tpos_dim) + obj_pos = self.obj_ptr_tpos_proj(obj_pos) + obj_pos = obj_pos.unsqueeze(1).expand(-1, B, self.mem_dim) + else: + obj_pos = obj_ptrs.new_zeros(len(pos_list), B, self.mem_dim) + if self.mem_dim < C: + obj_ptrs = obj_ptrs.reshape(-1, B, C // self.mem_dim, self.mem_dim) + obj_ptrs = obj_ptrs.permute(0, 2, 1, 3).flatten(0, 1) + obj_pos = obj_pos.repeat_interleave(C // self.mem_dim, dim=0) + to_cat_memory.append(obj_ptrs) + to_cat_memory_pos_embed.append(obj_pos) + num_obj_ptr_tokens = obj_ptrs.shape[0] + else: + num_obj_ptr_tokens = 0 + else: + if self.directly_add_no_mem_embed: + pix_feat_with_mem = current_vision_feats[-1] + self.no_mem_embed + pix_feat_with_mem = pix_feat_with_mem.permute(1, 2, 0).view(B, C, H, W) + return pix_feat_with_mem + to_cat_memory = [self.no_mem_embed.expand(1, B, self.mem_dim)] + to_cat_memory_pos_embed = [self.no_mem_pos_enc.expand(1, B, self.mem_dim)] + memory = torch.cat(to_cat_memory, dim=0) + memory_pos_embed = torch.cat(to_cat_memory_pos_embed, dim=0) + pix_feat_with_mem = self.memory_attention(curr=current_vision_feats, curr_pos=current_vision_pos_embeds, memory=memory, memory_pos=memory_pos_embed, num_obj_ptr_tokens=num_obj_ptr_tokens) + pix_feat_with_mem = pix_feat_with_mem.permute(1, 2, 0).view(B, C, H, W) + return pix_feat_with_mem + + def _encode_new_memory(self, current_vision_feats, feat_sizes, pred_masks_high_res, is_mask_from_pts): + B = current_vision_feats[-1].size(1) + C = self.hidden_dim + (H, W) = feat_sizes[-1] + pix_feat = current_vision_feats[-1].permute(1, 2, 0).view(B, C, H, W) + if self.non_overlap_masks_for_mem_enc and (not self.training): + pred_masks_high_res = self._apply_non_overlapping_constraints(pred_masks_high_res) + binarize = self.binarize_mask_from_pts_for_mem_enc and is_mask_from_pts + if binarize and (not self.training): + mask_for_mem = (pred_masks_high_res > 0).float() + else: + mask_for_mem = torch.sigmoid(pred_masks_high_res) + if self.sigmoid_scale_for_mem_enc != 1.0: + mask_for_mem = mask_for_mem * self.sigmoid_scale_for_mem_enc + if self.sigmoid_bias_for_mem_enc != 0.0: + mask_for_mem = mask_for_mem + self.sigmoid_bias_for_mem_enc + maskmem_out = self.memory_encoder(pix_feat, mask_for_mem, skip_mask_sigmoid=True) + maskmem_features = maskmem_out['vision_features'] + maskmem_pos_enc = maskmem_out['vision_pos_enc'] + return (maskmem_features, maskmem_pos_enc) + + def track_step(self, frame_idx, is_init_cond_frame, current_vision_feats, current_vision_pos_embeds, feat_sizes, point_inputs, mask_inputs, output_dict, num_frames, track_in_reverse=False, run_mem_encoder=True, prev_sam_mask_logits=None): + current_out = {'point_inputs': point_inputs, 'mask_inputs': mask_inputs} + if len(current_vision_feats) > 1: + high_res_features = [x.permute(1, 2, 0).view(x.size(1), x.size(2), *s) for (x, s) in zip(current_vision_feats[:-1], feat_sizes[:-1])] + else: + high_res_features = None + if mask_inputs is not None and self.use_mask_input_as_output_without_sam: + pix_feat = current_vision_feats[-1].permute(1, 2, 0) + pix_feat = pix_feat.view(-1, self.hidden_dim, *feat_sizes[-1]) + sam_outputs = self._use_mask_as_output(pix_feat, high_res_features, mask_inputs) + else: + pix_feat_with_mem = self._prepare_memory_conditioned_features(frame_idx=frame_idx, is_init_cond_frame=is_init_cond_frame, current_vision_feats=current_vision_feats[-1:], current_vision_pos_embeds=current_vision_pos_embeds[-1:], feat_sizes=feat_sizes[-1:], output_dict=output_dict, num_frames=num_frames, track_in_reverse=track_in_reverse) + if prev_sam_mask_logits is not None: + assert point_inputs is not None and mask_inputs is None + mask_inputs = prev_sam_mask_logits + multimask_output = self._use_multimask(is_init_cond_frame, point_inputs) + sam_outputs = self._forward_sam_heads(backbone_features=pix_feat_with_mem, point_inputs=point_inputs, mask_inputs=mask_inputs, high_res_features=high_res_features, multimask_output=multimask_output) + (_, _, _, low_res_masks, high_res_masks, obj_ptr, _) = sam_outputs + current_out['pred_masks'] = low_res_masks + current_out['pred_masks_high_res'] = high_res_masks + current_out['obj_ptr'] = obj_ptr + if run_mem_encoder and self.num_maskmem > 0: + high_res_masks_for_mem_enc = high_res_masks + (maskmem_features, maskmem_pos_enc) = self._encode_new_memory(current_vision_feats=current_vision_feats, feat_sizes=feat_sizes, pred_masks_high_res=high_res_masks_for_mem_enc, is_mask_from_pts=point_inputs is not None) + current_out['maskmem_features'] = maskmem_features + current_out['maskmem_pos_enc'] = maskmem_pos_enc + else: + current_out['maskmem_features'] = None + current_out['maskmem_pos_enc'] = None + return current_out + + def _use_multimask(self, is_init_cond_frame, point_inputs): + num_pts = 0 if point_inputs is None else point_inputs['point_labels'].size(1) + multimask_output = self.multimask_output_in_sam and (is_init_cond_frame or self.multimask_output_for_tracking) and (self.multimask_min_pt_num <= num_pts <= self.multimask_max_pt_num) + return multimask_output + + def _apply_non_overlapping_constraints(self, pred_masks): + batch_size = pred_masks.size(0) + if batch_size == 1: + return pred_masks + device = pred_masks.device + max_obj_inds = torch.argmax(pred_masks, dim=0, keepdim=True) + batch_obj_inds = torch.arange(batch_size, device=device)[:, None, None, None] + keep = max_obj_inds == batch_obj_inds + pred_masks = torch.where(keep, pred_masks, torch.clamp(pred_masks, max=-10.0)) + return pred_masks + +# File: segment-anything-2-coreml-conversion/sam2/modeling/sam2_utils.py +import copy +import torch +import torch.nn as nn +import torch.nn.functional as F + +def select_closest_cond_frames(frame_idx, cond_frame_outputs, max_cond_frame_num): + if max_cond_frame_num == -1 or len(cond_frame_outputs) <= max_cond_frame_num: + selected_outputs = cond_frame_outputs + unselected_outputs = {} + else: + assert max_cond_frame_num >= 2, 'we should allow using 2+ conditioning frames' + selected_outputs = {} + idx_before = max((t for t in cond_frame_outputs if t < frame_idx), default=None) + if idx_before is not None: + selected_outputs[idx_before] = cond_frame_outputs[idx_before] + idx_after = min((t for t in cond_frame_outputs if t >= frame_idx), default=None) + if idx_after is not None: + selected_outputs[idx_after] = cond_frame_outputs[idx_after] + num_remain = max_cond_frame_num - len(selected_outputs) + inds_remain = sorted((t for t in cond_frame_outputs if t not in selected_outputs), key=lambda x: abs(x - frame_idx))[:num_remain] + selected_outputs.update(((t, cond_frame_outputs[t]) for t in inds_remain)) + unselected_outputs = {t: v for (t, v) in cond_frame_outputs.items() if t not in selected_outputs} + return (selected_outputs, unselected_outputs) + +def get_1d_sine_pe(pos_inds, dim, temperature=10000): + pe_dim = dim // 2 + dim_t = torch.arange(pe_dim, dtype=torch.float32, device=pos_inds.device) + dim_t = temperature ** (2 * (dim_t // 2) / pe_dim) + pos_embed = pos_inds.unsqueeze(-1) / dim_t + pos_embed = torch.cat([pos_embed.sin(), pos_embed.cos()], dim=-1) + return pos_embed + +def get_activation_fn(activation): + if activation == 'relu': + return F.relu + if activation == 'gelu': + return F.gelu + if activation == 'glu': + return F.glu + raise RuntimeError(f'activation should be relu/gelu, not {activation}.') + +def get_clones(module, N): + return nn.ModuleList([copy.deepcopy(module) for i in range(N)]) + +class DropPath(nn.Module): + + def __init__(self, drop_prob=0.0, scale_by_keep=True): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + self.scale_by_keep = scale_by_keep + + def forward(self, x): + if self.drop_prob == 0.0 or not self.training: + return x + keep_prob = 1 - self.drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) + random_tensor = x.new_empty(shape).bernoulli_(keep_prob) + if keep_prob > 0.0 and self.scale_by_keep: + random_tensor.div_(keep_prob) + return x * random_tensor + +class MLP(nn.Module): + + def __init__(self, input_dim: int, hidden_dim: int, output_dim: int, num_layers: int, activation: nn.Module=nn.ReLU, sigmoid_output: bool=False) -> None: + super().__init__() + self.num_layers = num_layers + h = [hidden_dim] * (num_layers - 1) + self.layers = nn.ModuleList((nn.Linear(n, k) for (n, k) in zip([input_dim] + h, h + [output_dim]))) + self.sigmoid_output = sigmoid_output + self.act = activation() + + def forward(self, x): + for (i, layer) in enumerate(self.layers): + x = self.act(layer(x)) if i < self.num_layers - 1 else layer(x) + if self.sigmoid_output: + x = F.sigmoid(x) + return x + +class LayerNorm2d(nn.Module): + + def __init__(self, num_channels: int, eps: float=1e-06) -> None: + super().__init__() + self.weight = nn.Parameter(torch.ones(num_channels)) + self.bias = nn.Parameter(torch.zeros(num_channels)) + self.eps = eps + + def forward(self, x: torch.Tensor) -> torch.Tensor: + u = x.mean(1, keepdim=True) + s = (x - u).pow(2).mean(1, keepdim=True) + x = (x - u) / torch.sqrt(s + self.eps) + x = self.weight[:, None, None] * x + self.bias[:, None, None] + return x + +# File: segment-anything-2-coreml-conversion/sam2/sam2_image_predictor.py +import os +import logging +from typing import List, Optional, Tuple, Union +import numpy as np +import torch +from PIL.Image import Image +from sam2.modeling.sam2_base import SAM2Base +from sam2.utils.transforms import SAM2Transforms + +class SAM2ImagePredictor: + + def __init__(self, sam_model: SAM2Base, mask_threshold=0.0, max_hole_area=0.0, max_sprinkle_area=0.0, **kwargs) -> None: + super().__init__() + self.model = sam_model + self._transforms = SAM2Transforms(resolution=self.model.image_size, mask_threshold=mask_threshold, max_hole_area=max_hole_area, max_sprinkle_area=max_sprinkle_area) + self._is_image_set = False + self._features = None + self._orig_hw = None + self._is_batch = False + self.mask_threshold = mask_threshold + self._bb_feat_sizes = [(256, 256), (128, 128), (64, 64)] + + @classmethod + def from_pretrained(cls, model_id: str, **kwargs) -> 'SAM2ImagePredictor': + from sam2.build_sam import build_sam2_hf + sam_model = build_sam2_hf(model_id, **kwargs) + return cls(sam_model, **kwargs) + + @torch.no_grad() + def set_image(self, image: Union[np.ndarray, Image]) -> None: + self.reset_predictor() + if isinstance(image, np.ndarray): + logging.info('For numpy array image, we assume (HxWxC) format') + self._orig_hw = [image.shape[:2]] + elif isinstance(image, Image): + (w, h) = image.size + self._orig_hw = [(h, w)] + else: + raise NotImplementedError('Image format not supported') + input_image = self._transforms(image) + input_image = input_image[None, ...].to(self.device) + assert len(input_image.shape) == 4 and input_image.shape[1] == 3, f'input_image must be of size 1x3xHxW, got {input_image.shape}' + logging.info('Computing image embeddings for the provided image...') + backbone_out = self.model.forward_image(input_image) + (_, vision_feats, _, _) = self.model._prepare_backbone_features(backbone_out) + if self.model.directly_add_no_mem_embed: + vision_feats[-1] = vision_feats[-1] + self.model.no_mem_embed + feats = [feat.permute(1, 2, 0).view(1, -1, *feat_size) for (feat, feat_size) in zip(vision_feats[::-1], self._bb_feat_sizes[::-1])][::-1] + self._features = {'image_embed': feats[-1], 'high_res_feats': feats[:-1]} + self._is_image_set = True + serialize_ground = os.environ.get('SERIALIZE_GROUND', False) + if serialize_ground: + image_embed = self._features['image_embed'].cpu().numpy() + high_res_feats = self._features['high_res_feats'] + feats_s0 = high_res_feats[0].cpu().numpy() + feats_s1 = high_res_feats[1].cpu().numpy() + np.save('image_embed.npy', image_embed) + np.save('feats_s0.npy', feats_s0) + np.save('feats_s1.npy', feats_s1) + logging.info('Image embeddings computed.') + + @torch.no_grad() + def encode_image_raw(self, prepared_image: torch.Tensor): + self.model.eval() + with torch.no_grad(): + for (_, param) in self.model.named_parameters(): + if param.requires_grad: + param.requires_grad = False + backbone_out = self.model.forward_image(prepared_image) + (_, vision_feats, _, _) = self.model._prepare_backbone_features(backbone_out) + if self.model.directly_add_no_mem_embed: + vision_feats[-1] = vision_feats[-1] + self.model.no_mem_embed + feats = [feat.permute(1, 2, 0).view(1, -1, *feat_size) for (feat, feat_size) in zip(vision_feats[::-1], self._bb_feat_sizes[::-1])][::-1] + image_embed = feats[-1] + high_res_feats = feats[:-1] + assert len(high_res_feats) == 2 + (feats_s0, feats_s1) = (high_res_feats[0], high_res_feats[1]) + return (image_embed, feats_s0, feats_s1) + + @torch.no_grad() + def encode_points_raw(self, unnorm_coords: torch.Tensor, labels: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + concat_points = (unnorm_coords, labels) + with torch.no_grad(): + for (_, param) in self.model.named_parameters(): + if param.requires_grad: + param.requires_grad = False + (sparse_embeddings, dense_embeddings) = self.model.sam_prompt_encoder.points_only(points=concat_points) + return (sparse_embeddings, dense_embeddings) + + @torch.no_grad() + def decode_masks_raw(self, image_embeddings: torch.Tensor, sparse_embedding: torch.Tensor, dense_embedding: torch.Tensor, high_res_features: List[torch.Tensor], multimask_output: bool=True, batched_mode: bool=False): + with torch.no_grad(): + for (_, param) in self.model.sam_mask_decoder.named_parameters(): + if param.requires_grad: + param.requires_grad = False + (low_res_masks, iou_scores, _, _) = self.model.sam_mask_decoder(image_embeddings=image_embeddings, image_pe=self.model.sam_prompt_encoder.get_dense_pe(), sparse_prompt_embeddings=sparse_embedding, dense_prompt_embeddings=dense_embedding, multimask_output=multimask_output, repeat_image=batched_mode, high_res_features=high_res_features) + return (low_res_masks, iou_scores) + + @torch.no_grad() + def set_image_batch(self, image_list: List[Union[np.ndarray]]) -> None: + self.reset_predictor() + assert isinstance(image_list, list) + self._orig_hw = [] + for image in image_list: + assert isinstance(image, np.ndarray), 'Images are expected to be an np.ndarray in RGB format, and of shape HWC' + self._orig_hw.append(image.shape[:2]) + img_batch = self._transforms.forward_batch(image_list) + img_batch = img_batch.to(self.device) + batch_size = img_batch.shape[0] + assert len(img_batch.shape) == 4 and img_batch.shape[1] == 3, f'img_batch must be of size Bx3xHxW, got {img_batch.shape}' + logging.info('Computing image embeddings for the provided images...') + backbone_out = self.model.forward_image(img_batch) + (_, vision_feats, _, _) = self.model._prepare_backbone_features(backbone_out) + if self.model.directly_add_no_mem_embed: + vision_feats[-1] = vision_feats[-1] + self.model.no_mem_embed + feats = [feat.permute(1, 2, 0).view(batch_size, -1, *feat_size) for (feat, feat_size) in zip(vision_feats[::-1], self._bb_feat_sizes[::-1])][::-1] + self._features = {'image_embed': feats[-1], 'high_res_feats': feats[:-1]} + self._is_image_set = True + self._is_batch = True + logging.info('Image embeddings computed.') + + def predict_batch(self, point_coords_batch: List[np.ndarray]=None, point_labels_batch: List[np.ndarray]=None, box_batch: List[np.ndarray]=None, mask_input_batch: List[np.ndarray]=None, multimask_output: bool=True, return_logits: bool=False, normalize_coords=True) -> Tuple[List[np.ndarray], List[np.ndarray], List[np.ndarray]]: + assert self._is_batch, 'This function should only be used when in batched mode' + if not self._is_image_set: + raise RuntimeError('An image must be set with .set_image_batch(...) before mask prediction.') + num_images = len(self._features['image_embed']) + all_masks = [] + all_ious = [] + all_low_res_masks = [] + for img_idx in range(num_images): + point_coords = point_coords_batch[img_idx] if point_coords_batch is not None else None + point_labels = point_labels_batch[img_idx] if point_labels_batch is not None else None + box = box_batch[img_idx] if box_batch is not None else None + mask_input = mask_input_batch[img_idx] if mask_input_batch is not None else None + (mask_input, unnorm_coords, labels, unnorm_box) = self._prep_prompts(point_coords, point_labels, box, mask_input, normalize_coords, img_idx=img_idx) + (masks, iou_predictions, low_res_masks) = self._predict(unnorm_coords, labels, unnorm_box, mask_input, multimask_output, return_logits=return_logits, img_idx=img_idx) + masks_np = masks.squeeze(0).float().detach().cpu().numpy() + iou_predictions_np = iou_predictions.squeeze(0).float().detach().cpu().numpy() + low_res_masks_np = low_res_masks.squeeze(0).float().detach().cpu().numpy() + all_masks.append(masks_np) + all_ious.append(iou_predictions_np) + all_low_res_masks.append(low_res_masks_np) + return (all_masks, all_ious, all_low_res_masks) + + def predict(self, point_coords: Optional[np.ndarray]=None, point_labels: Optional[np.ndarray]=None, box: Optional[np.ndarray]=None, mask_input: Optional[np.ndarray]=None, multimask_output: bool=True, return_logits: bool=False, normalize_coords=True) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + if not self._is_image_set: + raise RuntimeError('An image must be set with .set_image(...) before mask prediction.') + (mask_input, unnorm_coords, labels, unnorm_box) = self._prep_prompts(point_coords, point_labels, box, mask_input, normalize_coords) + (masks, iou_predictions, low_res_masks) = self._predict(unnorm_coords, labels, unnorm_box, mask_input, multimask_output, return_logits=return_logits) + masks_np = masks.squeeze(0).float().detach().cpu().numpy() + iou_predictions_np = iou_predictions.squeeze(0).float().detach().cpu().numpy() + low_res_masks_np = low_res_masks.squeeze(0).float().detach().cpu().numpy() + return (masks_np, iou_predictions_np, low_res_masks_np) + + def _prep_prompts(self, point_coords, point_labels, box, mask_logits, normalize_coords, img_idx=-1): + (unnorm_coords, labels, unnorm_box, mask_input) = (None, None, None, None) + if point_coords is not None: + assert point_labels is not None, 'point_labels must be supplied if point_coords is supplied.' + point_coords = torch.as_tensor(point_coords, dtype=torch.float, device=self.device) + unnorm_coords = self._transforms.transform_coords(point_coords, normalize=normalize_coords, orig_hw=self._orig_hw[img_idx]) + labels = torch.as_tensor(point_labels, dtype=torch.int, device=self.device) + if len(unnorm_coords.shape) == 2: + (unnorm_coords, labels) = (unnorm_coords[None, ...], labels[None, ...]) + if box is not None: + box = torch.as_tensor(box, dtype=torch.float, device=self.device) + unnorm_box = self._transforms.transform_boxes(box, normalize=normalize_coords, orig_hw=self._orig_hw[img_idx]) + if mask_logits is not None: + mask_input = torch.as_tensor(mask_logits, dtype=torch.float, device=self.device) + if len(mask_input.shape) == 3: + mask_input = mask_input[None, :, :, :] + return (mask_input, unnorm_coords, labels, unnorm_box) + + @torch.no_grad() + def _predict(self, point_coords: Optional[torch.Tensor], point_labels: Optional[torch.Tensor], boxes: Optional[torch.Tensor]=None, mask_input: Optional[torch.Tensor]=None, multimask_output: bool=True, return_logits: bool=False, img_idx: int=-1) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + if not self._is_image_set: + raise RuntimeError('An image must be set with .set_image(...) before mask prediction.') + if point_coords is not None: + concat_points = (point_coords, point_labels) + else: + concat_points = None + if boxes is not None: + box_coords = boxes.reshape(-1, 2, 2) + box_labels = torch.tensor([[2, 3]], dtype=torch.int, device=boxes.device) + box_labels = box_labels.repeat(boxes.size(0), 1) + if concat_points is not None: + concat_coords = torch.cat([box_coords, concat_points[0]], dim=1) + concat_labels = torch.cat([box_labels, concat_points[1]], dim=1) + concat_points = (concat_coords, concat_labels) + else: + concat_points = (box_coords, box_labels) + (sparse_embeddings, dense_embeddings) = self.model.sam_prompt_encoder(points=concat_points, boxes=None, masks=mask_input) + batched_mode = concat_points is not None and concat_points[0].shape[0] > 1 + high_res_features = [feat_level[img_idx].unsqueeze(0) for feat_level in self._features['high_res_feats']] + (low_res_masks, iou_predictions, _, _) = self.model.sam_mask_decoder(image_embeddings=self._features['image_embed'][img_idx].unsqueeze(0), image_pe=self.model.sam_prompt_encoder.get_dense_pe(), sparse_prompt_embeddings=sparse_embeddings, dense_prompt_embeddings=dense_embeddings, multimask_output=multimask_output, repeat_image=batched_mode, high_res_features=high_res_features) + if os.environ.get('SERIALIZE_GROUND', False): + low_res_masks_np = low_res_masks.cpu().numpy() + np.save('low_res_masks.npy', low_res_masks_np) + masks = self._transforms.postprocess_masks(low_res_masks, self._orig_hw[img_idx]) + low_res_masks = torch.clamp(low_res_masks, -32.0, 32.0) + if not return_logits: + masks = masks > self.mask_threshold + return (masks, iou_predictions, low_res_masks) + + def get_image_embedding(self) -> torch.Tensor: + if not self._is_image_set: + raise RuntimeError('An image must be set with .set_image(...) to generate an embedding.') + assert self._features is not None, 'Features must exist if an image has been set.' + return self._features['image_embed'] + + @property + def device(self) -> torch.device: + return self.model.device + + def reset_predictor(self) -> None: + self._is_image_set = False + self._features = None + self._orig_hw = None + self._is_batch = False + +# File: segment-anything-2-coreml-conversion/sam2/sam2_video_predictor.py +import warnings +from collections import OrderedDict +import torch +from tqdm import tqdm +from sam2.modeling.sam2_base import NO_OBJ_SCORE, SAM2Base +from sam2.utils.misc import concat_points, fill_holes_in_mask_scores, load_video_frames + +class SAM2VideoPredictor(SAM2Base): + + def __init__(self, fill_hole_area=0, non_overlap_masks=False, clear_non_cond_mem_around_input=False, clear_non_cond_mem_for_multi_obj=False, **kwargs): + super().__init__(**kwargs) + self.fill_hole_area = fill_hole_area + self.non_overlap_masks = non_overlap_masks + self.clear_non_cond_mem_around_input = clear_non_cond_mem_around_input + self.clear_non_cond_mem_for_multi_obj = clear_non_cond_mem_for_multi_obj + + @torch.inference_mode() + def init_state(self, video_path, offload_video_to_cpu=False, offload_state_to_cpu=False, async_loading_frames=False): + compute_device = self.device + (images, video_height, video_width) = load_video_frames(video_path=video_path, image_size=self.image_size, offload_video_to_cpu=offload_video_to_cpu, async_loading_frames=async_loading_frames, compute_device=compute_device) + inference_state = {} + inference_state['images'] = images + inference_state['num_frames'] = len(images) + inference_state['offload_video_to_cpu'] = offload_video_to_cpu + inference_state['offload_state_to_cpu'] = offload_state_to_cpu + inference_state['video_height'] = video_height + inference_state['video_width'] = video_width + inference_state['device'] = compute_device + if offload_state_to_cpu: + inference_state['storage_device'] = torch.device('cpu') + else: + inference_state['storage_device'] = compute_device + inference_state['point_inputs_per_obj'] = {} + inference_state['mask_inputs_per_obj'] = {} + inference_state['cached_features'] = {} + inference_state['constants'] = {} + inference_state['obj_id_to_idx'] = OrderedDict() + inference_state['obj_idx_to_id'] = OrderedDict() + inference_state['obj_ids'] = [] + inference_state['output_dict'] = {'cond_frame_outputs': {}, 'non_cond_frame_outputs': {}} + inference_state['output_dict_per_obj'] = {} + inference_state['temp_output_dict_per_obj'] = {} + inference_state['consolidated_frame_inds'] = {'cond_frame_outputs': set(), 'non_cond_frame_outputs': set()} + inference_state['tracking_has_started'] = False + inference_state['frames_already_tracked'] = {} + self._get_image_feature(inference_state, frame_idx=0, batch_size=1) + return inference_state + + @classmethod + def from_pretrained(cls, model_id: str, **kwargs) -> 'SAM2VideoPredictor': + from sam2.build_sam import build_sam2_video_predictor_hf + sam_model = build_sam2_video_predictor_hf(model_id, **kwargs) + return sam_model + + def _obj_id_to_idx(self, inference_state, obj_id): + obj_idx = inference_state['obj_id_to_idx'].get(obj_id, None) + if obj_idx is not None: + return obj_idx + allow_new_object = not inference_state['tracking_has_started'] + if allow_new_object: + obj_idx = len(inference_state['obj_id_to_idx']) + inference_state['obj_id_to_idx'][obj_id] = obj_idx + inference_state['obj_idx_to_id'][obj_idx] = obj_id + inference_state['obj_ids'] = list(inference_state['obj_id_to_idx']) + inference_state['point_inputs_per_obj'][obj_idx] = {} + inference_state['mask_inputs_per_obj'][obj_idx] = {} + inference_state['output_dict_per_obj'][obj_idx] = {'cond_frame_outputs': {}, 'non_cond_frame_outputs': {}} + inference_state['temp_output_dict_per_obj'][obj_idx] = {'cond_frame_outputs': {}, 'non_cond_frame_outputs': {}} + return obj_idx + else: + raise RuntimeError(f"Cannot add new object id {obj_id} after tracking starts. All existing object ids: {inference_state['obj_ids']}. Please call 'reset_state' to restart from scratch.") + + def _obj_idx_to_id(self, inference_state, obj_idx): + return inference_state['obj_idx_to_id'][obj_idx] + + def _get_obj_num(self, inference_state): + return len(inference_state['obj_idx_to_id']) + + @torch.inference_mode() + def add_new_points_or_box(self, inference_state, frame_idx, obj_id, points=None, labels=None, clear_old_points=True, normalize_coords=True, box=None): + obj_idx = self._obj_id_to_idx(inference_state, obj_id) + point_inputs_per_frame = inference_state['point_inputs_per_obj'][obj_idx] + mask_inputs_per_frame = inference_state['mask_inputs_per_obj'][obj_idx] + if (points is not None) != (labels is not None): + raise ValueError('points and labels must be provided together') + if points is None and box is None: + raise ValueError('at least one of points or box must be provided as input') + if points is None: + points = torch.zeros(0, 2, dtype=torch.float32) + elif not isinstance(points, torch.Tensor): + points = torch.tensor(points, dtype=torch.float32) + if labels is None: + labels = torch.zeros(0, dtype=torch.int32) + elif not isinstance(labels, torch.Tensor): + labels = torch.tensor(labels, dtype=torch.int32) + if points.dim() == 2: + points = points.unsqueeze(0) + if labels.dim() == 1: + labels = labels.unsqueeze(0) + if box is not None: + if not clear_old_points: + raise ValueError('cannot add box without clearing old points, since box prompt must be provided before any point prompt (please use clear_old_points=True instead)') + if inference_state['tracking_has_started']: + warnings.warn("You are adding a box after tracking starts. SAM 2 may not always be able to incorporate a box prompt for *refinement*. If you intend to use box prompt as an *initial* input before tracking, please call 'reset_state' on the inference state to restart from scratch.", category=UserWarning, stacklevel=2) + if not isinstance(box, torch.Tensor): + box = torch.tensor(box, dtype=torch.float32, device=points.device) + box_coords = box.reshape(1, 2, 2) + box_labels = torch.tensor([2, 3], dtype=torch.int32, device=labels.device) + box_labels = box_labels.reshape(1, 2) + points = torch.cat([box_coords, points], dim=1) + labels = torch.cat([box_labels, labels], dim=1) + if normalize_coords: + video_H = inference_state['video_height'] + video_W = inference_state['video_width'] + points = points / torch.tensor([video_W, video_H]).to(points.device) + points = points * self.image_size + points = points.to(inference_state['device']) + labels = labels.to(inference_state['device']) + if not clear_old_points: + point_inputs = point_inputs_per_frame.get(frame_idx, None) + else: + point_inputs = None + point_inputs = concat_points(point_inputs, points, labels) + point_inputs_per_frame[frame_idx] = point_inputs + mask_inputs_per_frame.pop(frame_idx, None) + is_init_cond_frame = frame_idx not in inference_state['frames_already_tracked'] + if is_init_cond_frame: + reverse = False + else: + reverse = inference_state['frames_already_tracked'][frame_idx]['reverse'] + obj_output_dict = inference_state['output_dict_per_obj'][obj_idx] + obj_temp_output_dict = inference_state['temp_output_dict_per_obj'][obj_idx] + is_cond = is_init_cond_frame or self.add_all_frames_to_correct_as_cond + storage_key = 'cond_frame_outputs' if is_cond else 'non_cond_frame_outputs' + prev_sam_mask_logits = None + prev_out = obj_temp_output_dict[storage_key].get(frame_idx) + if prev_out is None: + prev_out = obj_output_dict['cond_frame_outputs'].get(frame_idx) + if prev_out is None: + prev_out = obj_output_dict['non_cond_frame_outputs'].get(frame_idx) + if prev_out is not None and prev_out['pred_masks'] is not None: + device = inference_state['device'] + prev_sam_mask_logits = prev_out['pred_masks'].to(device, non_blocking=True) + prev_sam_mask_logits = torch.clamp(prev_sam_mask_logits, -32.0, 32.0) + (current_out, _) = self._run_single_frame_inference(inference_state=inference_state, output_dict=obj_output_dict, frame_idx=frame_idx, batch_size=1, is_init_cond_frame=is_init_cond_frame, point_inputs=point_inputs, mask_inputs=None, reverse=reverse, run_mem_encoder=False, prev_sam_mask_logits=prev_sam_mask_logits) + obj_temp_output_dict[storage_key][frame_idx] = current_out + obj_ids = inference_state['obj_ids'] + consolidated_out = self._consolidate_temp_output_across_obj(inference_state, frame_idx, is_cond=is_cond, run_mem_encoder=False, consolidate_at_video_res=True) + (_, video_res_masks) = self._get_orig_video_res_output(inference_state, consolidated_out['pred_masks_video_res']) + return (frame_idx, obj_ids, video_res_masks) + + def add_new_points(self, *args, **kwargs): + return self.add_new_points_or_box(*args, **kwargs) + + @torch.inference_mode() + def add_new_mask(self, inference_state, frame_idx, obj_id, mask): + obj_idx = self._obj_id_to_idx(inference_state, obj_id) + point_inputs_per_frame = inference_state['point_inputs_per_obj'][obj_idx] + mask_inputs_per_frame = inference_state['mask_inputs_per_obj'][obj_idx] + if not isinstance(mask, torch.Tensor): + mask = torch.tensor(mask, dtype=torch.bool) + assert mask.dim() == 2 + (mask_H, mask_W) = mask.shape + mask_inputs_orig = mask[None, None] + mask_inputs_orig = mask_inputs_orig.float().to(inference_state['device']) + if mask_H != self.image_size or mask_W != self.image_size: + mask_inputs = torch.nn.functional.interpolate(mask_inputs_orig, size=(self.image_size, self.image_size), align_corners=False, mode='bilinear', antialias=True) + mask_inputs = (mask_inputs >= 0.5).float() + else: + mask_inputs = mask_inputs_orig + mask_inputs_per_frame[frame_idx] = mask_inputs + point_inputs_per_frame.pop(frame_idx, None) + is_init_cond_frame = frame_idx not in inference_state['frames_already_tracked'] + if is_init_cond_frame: + reverse = False + else: + reverse = inference_state['frames_already_tracked'][frame_idx]['reverse'] + obj_output_dict = inference_state['output_dict_per_obj'][obj_idx] + obj_temp_output_dict = inference_state['temp_output_dict_per_obj'][obj_idx] + is_cond = is_init_cond_frame or self.add_all_frames_to_correct_as_cond + storage_key = 'cond_frame_outputs' if is_cond else 'non_cond_frame_outputs' + (current_out, _) = self._run_single_frame_inference(inference_state=inference_state, output_dict=obj_output_dict, frame_idx=frame_idx, batch_size=1, is_init_cond_frame=is_init_cond_frame, point_inputs=None, mask_inputs=mask_inputs, reverse=reverse, run_mem_encoder=False) + obj_temp_output_dict[storage_key][frame_idx] = current_out + obj_ids = inference_state['obj_ids'] + consolidated_out = self._consolidate_temp_output_across_obj(inference_state, frame_idx, is_cond=is_cond, run_mem_encoder=False, consolidate_at_video_res=True) + (_, video_res_masks) = self._get_orig_video_res_output(inference_state, consolidated_out['pred_masks_video_res']) + return (frame_idx, obj_ids, video_res_masks) + + def _get_orig_video_res_output(self, inference_state, any_res_masks): + device = inference_state['device'] + video_H = inference_state['video_height'] + video_W = inference_state['video_width'] + any_res_masks = any_res_masks.to(device, non_blocking=True) + if any_res_masks.shape[-2:] == (video_H, video_W): + video_res_masks = any_res_masks + else: + video_res_masks = torch.nn.functional.interpolate(any_res_masks, size=(video_H, video_W), mode='bilinear', align_corners=False) + if self.non_overlap_masks: + video_res_masks = self._apply_non_overlapping_constraints(video_res_masks) + return (any_res_masks, video_res_masks) + + def _consolidate_temp_output_across_obj(self, inference_state, frame_idx, is_cond, run_mem_encoder, consolidate_at_video_res=False): + batch_size = self._get_obj_num(inference_state) + storage_key = 'cond_frame_outputs' if is_cond else 'non_cond_frame_outputs' + if consolidate_at_video_res: + assert not run_mem_encoder, 'memory encoder cannot run at video resolution' + consolidated_H = inference_state['video_height'] + consolidated_W = inference_state['video_width'] + consolidated_mask_key = 'pred_masks_video_res' + else: + consolidated_H = consolidated_W = self.image_size // 4 + consolidated_mask_key = 'pred_masks' + consolidated_out = {'maskmem_features': None, 'maskmem_pos_enc': None, consolidated_mask_key: torch.full(size=(batch_size, 1, consolidated_H, consolidated_W), fill_value=NO_OBJ_SCORE, dtype=torch.float32, device=inference_state['storage_device']), 'obj_ptr': torch.full(size=(batch_size, self.hidden_dim), fill_value=NO_OBJ_SCORE, dtype=torch.float32, device=inference_state['device'])} + empty_mask_ptr = None + for obj_idx in range(batch_size): + obj_temp_output_dict = inference_state['temp_output_dict_per_obj'][obj_idx] + obj_output_dict = inference_state['output_dict_per_obj'][obj_idx] + out = obj_temp_output_dict[storage_key].get(frame_idx, None) + if out is None: + out = obj_output_dict['cond_frame_outputs'].get(frame_idx, None) + if out is None: + out = obj_output_dict['non_cond_frame_outputs'].get(frame_idx, None) + if out is None: + if run_mem_encoder: + if empty_mask_ptr is None: + empty_mask_ptr = self._get_empty_mask_ptr(inference_state, frame_idx) + consolidated_out['obj_ptr'][obj_idx:obj_idx + 1] = empty_mask_ptr + continue + obj_mask = out['pred_masks'] + consolidated_pred_masks = consolidated_out[consolidated_mask_key] + if obj_mask.shape[-2:] == consolidated_pred_masks.shape[-2:]: + consolidated_pred_masks[obj_idx:obj_idx + 1] = obj_mask + else: + resized_obj_mask = torch.nn.functional.interpolate(obj_mask, size=consolidated_pred_masks.shape[-2:], mode='bilinear', align_corners=False) + consolidated_pred_masks[obj_idx:obj_idx + 1] = resized_obj_mask + consolidated_out['obj_ptr'][obj_idx:obj_idx + 1] = out['obj_ptr'] + if run_mem_encoder: + device = inference_state['device'] + high_res_masks = torch.nn.functional.interpolate(consolidated_out['pred_masks'].to(device, non_blocking=True), size=(self.image_size, self.image_size), mode='bilinear', align_corners=False) + if self.non_overlap_masks_for_mem_enc: + high_res_masks = self._apply_non_overlapping_constraints(high_res_masks) + (maskmem_features, maskmem_pos_enc) = self._run_memory_encoder(inference_state=inference_state, frame_idx=frame_idx, batch_size=batch_size, high_res_masks=high_res_masks, is_mask_from_pts=True) + consolidated_out['maskmem_features'] = maskmem_features + consolidated_out['maskmem_pos_enc'] = maskmem_pos_enc + return consolidated_out + + def _get_empty_mask_ptr(self, inference_state, frame_idx): + batch_size = 1 + mask_inputs = torch.zeros((batch_size, 1, self.image_size, self.image_size), dtype=torch.float32, device=inference_state['device']) + (_, _, current_vision_feats, current_vision_pos_embeds, feat_sizes) = self._get_image_feature(inference_state, frame_idx, batch_size) + current_out = self.track_step(frame_idx=frame_idx, is_init_cond_frame=True, current_vision_feats=current_vision_feats, current_vision_pos_embeds=current_vision_pos_embeds, feat_sizes=feat_sizes, point_inputs=None, mask_inputs=mask_inputs, output_dict={}, num_frames=inference_state['num_frames'], track_in_reverse=False, run_mem_encoder=False, prev_sam_mask_logits=None) + return current_out['obj_ptr'] + + @torch.inference_mode() + def propagate_in_video_preflight(self, inference_state): + inference_state['tracking_has_started'] = True + batch_size = self._get_obj_num(inference_state) + temp_output_dict_per_obj = inference_state['temp_output_dict_per_obj'] + output_dict = inference_state['output_dict'] + consolidated_frame_inds = inference_state['consolidated_frame_inds'] + for is_cond in [False, True]: + storage_key = 'cond_frame_outputs' if is_cond else 'non_cond_frame_outputs' + temp_frame_inds = set() + for obj_temp_output_dict in temp_output_dict_per_obj.values(): + temp_frame_inds.update(obj_temp_output_dict[storage_key].keys()) + consolidated_frame_inds[storage_key].update(temp_frame_inds) + for frame_idx in temp_frame_inds: + consolidated_out = self._consolidate_temp_output_across_obj(inference_state, frame_idx, is_cond=is_cond, run_mem_encoder=True) + output_dict[storage_key][frame_idx] = consolidated_out + self._add_output_per_object(inference_state, frame_idx, consolidated_out, storage_key) + clear_non_cond_mem = self.clear_non_cond_mem_around_input and (self.clear_non_cond_mem_for_multi_obj or batch_size <= 1) + if clear_non_cond_mem: + self._clear_non_cond_mem_around_input(inference_state, frame_idx) + for obj_temp_output_dict in temp_output_dict_per_obj.values(): + obj_temp_output_dict[storage_key].clear() + for frame_idx in output_dict['cond_frame_outputs']: + output_dict['non_cond_frame_outputs'].pop(frame_idx, None) + for obj_output_dict in inference_state['output_dict_per_obj'].values(): + for frame_idx in obj_output_dict['cond_frame_outputs']: + obj_output_dict['non_cond_frame_outputs'].pop(frame_idx, None) + for frame_idx in consolidated_frame_inds['cond_frame_outputs']: + assert frame_idx in output_dict['cond_frame_outputs'] + consolidated_frame_inds['non_cond_frame_outputs'].discard(frame_idx) + all_consolidated_frame_inds = consolidated_frame_inds['cond_frame_outputs'] | consolidated_frame_inds['non_cond_frame_outputs'] + input_frames_inds = set() + for point_inputs_per_frame in inference_state['point_inputs_per_obj'].values(): + input_frames_inds.update(point_inputs_per_frame.keys()) + for mask_inputs_per_frame in inference_state['mask_inputs_per_obj'].values(): + input_frames_inds.update(mask_inputs_per_frame.keys()) + assert all_consolidated_frame_inds == input_frames_inds + + @torch.inference_mode() + def propagate_in_video(self, inference_state, start_frame_idx=None, max_frame_num_to_track=None, reverse=False): + self.propagate_in_video_preflight(inference_state) + output_dict = inference_state['output_dict'] + consolidated_frame_inds = inference_state['consolidated_frame_inds'] + obj_ids = inference_state['obj_ids'] + num_frames = inference_state['num_frames'] + batch_size = self._get_obj_num(inference_state) + if len(output_dict['cond_frame_outputs']) == 0: + raise RuntimeError('No points are provided; please add points first') + clear_non_cond_mem = self.clear_non_cond_mem_around_input and (self.clear_non_cond_mem_for_multi_obj or batch_size <= 1) + if start_frame_idx is None: + start_frame_idx = min(output_dict['cond_frame_outputs']) + if max_frame_num_to_track is None: + max_frame_num_to_track = num_frames + if reverse: + end_frame_idx = max(start_frame_idx - max_frame_num_to_track, 0) + if start_frame_idx > 0: + processing_order = range(start_frame_idx, end_frame_idx - 1, -1) + else: + processing_order = [] + else: + end_frame_idx = min(start_frame_idx + max_frame_num_to_track, num_frames - 1) + processing_order = range(start_frame_idx, end_frame_idx + 1) + for frame_idx in tqdm(processing_order, desc='propagate in video'): + if frame_idx in consolidated_frame_inds['cond_frame_outputs']: + storage_key = 'cond_frame_outputs' + current_out = output_dict[storage_key][frame_idx] + pred_masks = current_out['pred_masks'] + if clear_non_cond_mem: + self._clear_non_cond_mem_around_input(inference_state, frame_idx) + elif frame_idx in consolidated_frame_inds['non_cond_frame_outputs']: + storage_key = 'non_cond_frame_outputs' + current_out = output_dict[storage_key][frame_idx] + pred_masks = current_out['pred_masks'] + else: + storage_key = 'non_cond_frame_outputs' + (current_out, pred_masks) = self._run_single_frame_inference(inference_state=inference_state, output_dict=output_dict, frame_idx=frame_idx, batch_size=batch_size, is_init_cond_frame=False, point_inputs=None, mask_inputs=None, reverse=reverse, run_mem_encoder=True) + output_dict[storage_key][frame_idx] = current_out + self._add_output_per_object(inference_state, frame_idx, current_out, storage_key) + inference_state['frames_already_tracked'][frame_idx] = {'reverse': reverse} + (_, video_res_masks) = self._get_orig_video_res_output(inference_state, pred_masks) + yield (frame_idx, obj_ids, video_res_masks) + + def _add_output_per_object(self, inference_state, frame_idx, current_out, storage_key): + maskmem_features = current_out['maskmem_features'] + assert maskmem_features is None or isinstance(maskmem_features, torch.Tensor) + maskmem_pos_enc = current_out['maskmem_pos_enc'] + assert maskmem_pos_enc is None or isinstance(maskmem_pos_enc, list) + output_dict_per_obj = inference_state['output_dict_per_obj'] + for (obj_idx, obj_output_dict) in output_dict_per_obj.items(): + obj_slice = slice(obj_idx, obj_idx + 1) + obj_out = {'maskmem_features': None, 'maskmem_pos_enc': None, 'pred_masks': current_out['pred_masks'][obj_slice], 'obj_ptr': current_out['obj_ptr'][obj_slice]} + if maskmem_features is not None: + obj_out['maskmem_features'] = maskmem_features[obj_slice] + if maskmem_pos_enc is not None: + obj_out['maskmem_pos_enc'] = [x[obj_slice] for x in maskmem_pos_enc] + obj_output_dict[storage_key][frame_idx] = obj_out + + @torch.inference_mode() + def reset_state(self, inference_state): + self._reset_tracking_results(inference_state) + inference_state['obj_id_to_idx'].clear() + inference_state['obj_idx_to_id'].clear() + inference_state['obj_ids'].clear() + inference_state['point_inputs_per_obj'].clear() + inference_state['mask_inputs_per_obj'].clear() + inference_state['output_dict_per_obj'].clear() + inference_state['temp_output_dict_per_obj'].clear() + + def _reset_tracking_results(self, inference_state): + for v in inference_state['point_inputs_per_obj'].values(): + v.clear() + for v in inference_state['mask_inputs_per_obj'].values(): + v.clear() + for v in inference_state['output_dict_per_obj'].values(): + v['cond_frame_outputs'].clear() + v['non_cond_frame_outputs'].clear() + for v in inference_state['temp_output_dict_per_obj'].values(): + v['cond_frame_outputs'].clear() + v['non_cond_frame_outputs'].clear() + inference_state['output_dict']['cond_frame_outputs'].clear() + inference_state['output_dict']['non_cond_frame_outputs'].clear() + inference_state['consolidated_frame_inds']['cond_frame_outputs'].clear() + inference_state['consolidated_frame_inds']['non_cond_frame_outputs'].clear() + inference_state['tracking_has_started'] = False + inference_state['frames_already_tracked'].clear() + + def _get_image_feature(self, inference_state, frame_idx, batch_size): + (image, backbone_out) = inference_state['cached_features'].get(frame_idx, (None, None)) + if backbone_out is None: + device = inference_state['device'] + image = inference_state['images'][frame_idx].to(device).float().unsqueeze(0) + backbone_out = self.forward_image(image) + inference_state['cached_features'] = {frame_idx: (image, backbone_out)} + expanded_image = image.expand(batch_size, -1, -1, -1) + expanded_backbone_out = {'backbone_fpn': backbone_out['backbone_fpn'].copy(), 'vision_pos_enc': backbone_out['vision_pos_enc'].copy()} + for (i, feat) in enumerate(expanded_backbone_out['backbone_fpn']): + expanded_backbone_out['backbone_fpn'][i] = feat.expand(batch_size, -1, -1, -1) + for (i, pos) in enumerate(expanded_backbone_out['vision_pos_enc']): + pos = pos.expand(batch_size, -1, -1, -1) + expanded_backbone_out['vision_pos_enc'][i] = pos + features = self._prepare_backbone_features(expanded_backbone_out) + features = (expanded_image,) + features + return features + + def _run_single_frame_inference(self, inference_state, output_dict, frame_idx, batch_size, is_init_cond_frame, point_inputs, mask_inputs, reverse, run_mem_encoder, prev_sam_mask_logits=None): + (_, _, current_vision_feats, current_vision_pos_embeds, feat_sizes) = self._get_image_feature(inference_state, frame_idx, batch_size) + assert point_inputs is None or mask_inputs is None + current_out = self.track_step(frame_idx=frame_idx, is_init_cond_frame=is_init_cond_frame, current_vision_feats=current_vision_feats, current_vision_pos_embeds=current_vision_pos_embeds, feat_sizes=feat_sizes, point_inputs=point_inputs, mask_inputs=mask_inputs, output_dict=output_dict, num_frames=inference_state['num_frames'], track_in_reverse=reverse, run_mem_encoder=run_mem_encoder, prev_sam_mask_logits=prev_sam_mask_logits) + storage_device = inference_state['storage_device'] + maskmem_features = current_out['maskmem_features'] + if maskmem_features is not None: + maskmem_features = maskmem_features.to(torch.bfloat16) + maskmem_features = maskmem_features.to(storage_device, non_blocking=True) + pred_masks_gpu = current_out['pred_masks'] + if self.fill_hole_area > 0: + pred_masks_gpu = fill_holes_in_mask_scores(pred_masks_gpu, self.fill_hole_area) + pred_masks = pred_masks_gpu.to(storage_device, non_blocking=True) + maskmem_pos_enc = self._get_maskmem_pos_enc(inference_state, current_out) + obj_ptr = current_out['obj_ptr'] + compact_current_out = {'maskmem_features': maskmem_features, 'maskmem_pos_enc': maskmem_pos_enc, 'pred_masks': pred_masks, 'obj_ptr': obj_ptr} + return (compact_current_out, pred_masks_gpu) + + def _run_memory_encoder(self, inference_state, frame_idx, batch_size, high_res_masks, is_mask_from_pts): + (_, _, current_vision_feats, _, feat_sizes) = self._get_image_feature(inference_state, frame_idx, batch_size) + (maskmem_features, maskmem_pos_enc) = self._encode_new_memory(current_vision_feats=current_vision_feats, feat_sizes=feat_sizes, pred_masks_high_res=high_res_masks, is_mask_from_pts=is_mask_from_pts) + storage_device = inference_state['storage_device'] + maskmem_features = maskmem_features.to(torch.bfloat16) + maskmem_features = maskmem_features.to(storage_device, non_blocking=True) + maskmem_pos_enc = self._get_maskmem_pos_enc(inference_state, {'maskmem_pos_enc': maskmem_pos_enc}) + return (maskmem_features, maskmem_pos_enc) + + def _get_maskmem_pos_enc(self, inference_state, current_out): + model_constants = inference_state['constants'] + out_maskmem_pos_enc = current_out['maskmem_pos_enc'] + if out_maskmem_pos_enc is not None: + if 'maskmem_pos_enc' not in model_constants: + assert isinstance(out_maskmem_pos_enc, list) + maskmem_pos_enc = [x[0:1].clone() for x in out_maskmem_pos_enc] + model_constants['maskmem_pos_enc'] = maskmem_pos_enc + else: + maskmem_pos_enc = model_constants['maskmem_pos_enc'] + batch_size = out_maskmem_pos_enc[0].size(0) + expanded_maskmem_pos_enc = [x.expand(batch_size, -1, -1, -1) for x in maskmem_pos_enc] + else: + expanded_maskmem_pos_enc = None + return expanded_maskmem_pos_enc + + def _clear_non_cond_mem_around_input(self, inference_state, frame_idx): + r = self.memory_temporal_stride_for_eval + frame_idx_begin = frame_idx - r * self.num_maskmem + frame_idx_end = frame_idx + r * self.num_maskmem + output_dict = inference_state['output_dict'] + non_cond_frame_outputs = output_dict['non_cond_frame_outputs'] + for t in range(frame_idx_begin, frame_idx_end + 1): + non_cond_frame_outputs.pop(t, None) + for obj_output_dict in inference_state['output_dict_per_obj'].values(): + obj_output_dict['non_cond_frame_outputs'].pop(t, None) + +# File: segment-anything-2-coreml-conversion/sav_dataset/sav_evaluator.py +from argparse import ArgumentParser +from utils.sav_benchmark import benchmark +'' +parser = ArgumentParser() +parser.add_argument('--gt_root', required=True, help="Path to the GT folder. For SA-V, it's sav_val/Annotations_6fps or sav_test/Annotations_6fps") +parser.add_argument('--pred_root', required=True, help='Path to a folder containing folders of masks to be evaluated, with exactly the same structure as gt_root') +parser.add_argument('-n', '--num_processes', default=16, type=int, help='Number of concurrent processes') +parser.add_argument('-s', '--strict', help='Make sure every video in the gt_root folder has a corresponding video in the prediction', action='store_true') +parser.add_argument('-q', '--quiet', help='Quietly run evaluation without printing the information out', action='store_true') +parser.add_argument('--do_not_skip_first_and_last_frame', help="In SA-V val and test, we skip the first and the last annotated frames in evaluation. Set this to true for evaluation on settings that doesn't skip first and last frames", action='store_true') +if __name__ == '__main__': + args = parser.parse_args() + benchmark([args.gt_root], [args.pred_root], args.strict, args.num_processes, verbose=not args.quiet, skip_first_and_last=not args.do_not_skip_first_and_last_frame) + +# File: segment-anything-2-coreml-conversion/tools/vos_inference.py +import argparse +import os +import numpy as np +import torch +from PIL import Image +from sam2.build_sam import build_sam2_video_predictor +DAVIS_PALETTE = b'\x00\x00\x00\x80\x00\x00\x00\x80\x00\x80\x80\x00\x00\x00\x80\x80\x00\x80\x00\x80\x80\x80\x80\x80@\x00\x00\xc0\x00\x00@\x80\x00\xc0\x80\x00@\x00\x80\xc0\x00\x80@\x80\x80\xc0\x80\x80\x00@\x00\x80@\x00\x00\xc0\x00\x80\xc0\x00\x00@\x80\x80@\x80\x00\xc0\x80\x80\xc0\x80@@\x00\xc0@\x00@\xc0\x00\xc0\xc0\x00@@\x80\xc0@\x80@\xc0\x80\xc0\xc0\x80\x00\x00@\x80\x00@\x00\x80@\x80\x80@\x00\x00\xc0\x80\x00\xc0\x00\x80\xc0\x80\x80\xc0@\x00@\xc0\x00@@\x80@\xc0\x80@@\x00\xc0\xc0\x00\xc0@\x80\xc0\xc0\x80\xc0\x00@@\x80@@\x00\xc0@\x80\xc0@\x00@\xc0\x80@\xc0\x00\xc0\xc0\x80\xc0\xc0@@@\xc0@@@\xc0@\xc0\xc0@@@\xc0\xc0@\xc0@\xc0\xc0\xc0\xc0\xc0 \x00\x00\xa0\x00\x00 \x80\x00\xa0\x80\x00 \x00\x80\xa0\x00\x80 \x80\x80\xa0\x80\x80`\x00\x00\xe0\x00\x00`\x80\x00\xe0\x80\x00`\x00\x80\xe0\x00\x80`\x80\x80\xe0\x80\x80 @\x00\xa0@\x00 \xc0\x00\xa0\xc0\x00 @\x80\xa0@\x80 \xc0\x80\xa0\xc0\x80`@\x00\xe0@\x00`\xc0\x00\xe0\xc0\x00`@\x80\xe0@\x80`\xc0\x80\xe0\xc0\x80 \x00@\xa0\x00@ \x80@\xa0\x80@ \x00\xc0\xa0\x00\xc0 \x80\xc0\xa0\x80\xc0`\x00@\xe0\x00@`\x80@\xe0\x80@`\x00\xc0\xe0\x00\xc0`\x80\xc0\xe0\x80\xc0 @@\xa0@@ \xc0@\xa0\xc0@ @\xc0\xa0@\xc0 \xc0\xc0\xa0\xc0\xc0`@@\xe0@@`\xc0@\xe0\xc0@`@\xc0\xe0@\xc0`\xc0\xc0\xe0\xc0\xc0\x00 \x00\x80 \x00\x00\xa0\x00\x80\xa0\x00\x00 \x80\x80 \x80\x00\xa0\x80\x80\xa0\x80@ \x00\xc0 \x00@\xa0\x00\xc0\xa0\x00@ \x80\xc0 \x80@\xa0\x80\xc0\xa0\x80\x00`\x00\x80`\x00\x00\xe0\x00\x80\xe0\x00\x00`\x80\x80`\x80\x00\xe0\x80\x80\xe0\x80@`\x00\xc0`\x00@\xe0\x00\xc0\xe0\x00@`\x80\xc0`\x80@\xe0\x80\xc0\xe0\x80\x00 @\x80 @\x00\xa0@\x80\xa0@\x00 \xc0\x80 \xc0\x00\xa0\xc0\x80\xa0\xc0@ @\xc0 @@\xa0@\xc0\xa0@@ \xc0\xc0 \xc0@\xa0\xc0\xc0\xa0\xc0\x00`@\x80`@\x00\xe0@\x80\xe0@\x00`\xc0\x80`\xc0\x00\xe0\xc0\x80\xe0\xc0@`@\xc0`@@\xe0@\xc0\xe0@@`\xc0\xc0`\xc0@\xe0\xc0\xc0\xe0\xc0 \x00\xa0 \x00 \xa0\x00\xa0\xa0\x00 \x80\xa0 \x80 \xa0\x80\xa0\xa0\x80` \x00\xe0 \x00`\xa0\x00\xe0\xa0\x00` \x80\xe0 \x80`\xa0\x80\xe0\xa0\x80 `\x00\xa0`\x00 \xe0\x00\xa0\xe0\x00 `\x80\xa0`\x80 \xe0\x80\xa0\xe0\x80``\x00\xe0`\x00`\xe0\x00\xe0\xe0\x00``\x80\xe0`\x80`\xe0\x80\xe0\xe0\x80 @\xa0 @ \xa0@\xa0\xa0@ \xc0\xa0 \xc0 \xa0\xc0\xa0\xa0\xc0` @\xe0 @`\xa0@\xe0\xa0@` \xc0\xe0 \xc0`\xa0\xc0\xe0\xa0\xc0 `@\xa0`@ \xe0@\xa0\xe0@ `\xc0\xa0`\xc0 \xe0\xc0\xa0\xe0\xc0``@\xe0`@`\xe0@\xe0\xe0@``\xc0\xe0`\xc0`\xe0\xc0\xe0\xe0\xc0' + +def load_ann_png(path): + mask = Image.open(path) + palette = mask.getpalette() + mask = np.array(mask).astype(np.uint8) + return (mask, palette) + +def save_ann_png(path, mask, palette): + assert mask.dtype == np.uint8 + assert mask.ndim == 2 + output_mask = Image.fromarray(mask) + output_mask.putpalette(palette) + output_mask.save(path) + +def get_per_obj_mask(mask): + object_ids = np.unique(mask) + object_ids = object_ids[object_ids > 0].tolist() + per_obj_mask = {object_id: mask == object_id for object_id in object_ids} + return per_obj_mask + +def put_per_obj_mask(per_obj_mask, height, width): + mask = np.zeros((height, width), dtype=np.uint8) + object_ids = sorted(per_obj_mask)[::-1] + for object_id in object_ids: + object_mask = per_obj_mask[object_id] + object_mask = object_mask.reshape(height, width) + mask[object_mask] = object_id + return mask + +def load_masks_from_dir(input_mask_dir, video_name, frame_name, per_obj_png_file): + if not per_obj_png_file: + input_mask_path = os.path.join(input_mask_dir, video_name, f'{frame_name}.png') + (input_mask, input_palette) = load_ann_png(input_mask_path) + per_obj_input_mask = get_per_obj_mask(input_mask) + else: + per_obj_input_mask = {} + for object_name in os.listdir(os.path.join(input_mask_dir, video_name)): + object_id = int(object_name) + input_mask_path = os.path.join(input_mask_dir, video_name, object_name, f'{frame_name}.png') + (input_mask, input_palette) = load_ann_png(input_mask_path) + per_obj_input_mask[object_id] = input_mask > 0 + return (per_obj_input_mask, input_palette) + +def save_masks_to_dir(output_mask_dir, video_name, frame_name, per_obj_output_mask, height, width, per_obj_png_file, output_palette): + os.makedirs(os.path.join(output_mask_dir, video_name), exist_ok=True) + if not per_obj_png_file: + output_mask = put_per_obj_mask(per_obj_output_mask, height, width) + output_mask_path = os.path.join(output_mask_dir, video_name, f'{frame_name}.png') + save_ann_png(output_mask_path, output_mask, output_palette) + else: + for (object_id, object_mask) in per_obj_output_mask.items(): + object_name = f'{object_id:03d}' + os.makedirs(os.path.join(output_mask_dir, video_name, object_name), exist_ok=True) + output_mask = object_mask.reshape(height, width).astype(np.uint8) + output_mask_path = os.path.join(output_mask_dir, video_name, object_name, f'{frame_name}.png') + save_ann_png(output_mask_path, output_mask, output_palette) + +@torch.inference_mode() +@torch.autocast(device_type='cuda', dtype=torch.bfloat16) +def vos_inference(predictor, base_video_dir, input_mask_dir, output_mask_dir, video_name, score_thresh=0.0, use_all_masks=False, per_obj_png_file=False): + video_dir = os.path.join(base_video_dir, video_name) + frame_names = [os.path.splitext(p)[0] for p in os.listdir(video_dir) if os.path.splitext(p)[-1] in ['.jpg', '.jpeg', '.JPG', '.JPEG']] + frame_names.sort(key=lambda p: int(os.path.splitext(p)[0])) + inference_state = predictor.init_state(video_path=video_dir, async_loading_frames=False) + height = inference_state['video_height'] + width = inference_state['video_width'] + input_palette = None + if not use_all_masks: + input_frame_inds = [0] + else: + if not per_obj_png_file: + input_frame_inds = [idx for (idx, name) in enumerate(frame_names) if os.path.exists(os.path.join(input_mask_dir, video_name, f'{name}.png'))] + else: + input_frame_inds = [idx for object_name in os.listdir(os.path.join(input_mask_dir, video_name)) for (idx, name) in enumerate(frame_names) if os.path.exists(os.path.join(input_mask_dir, video_name, object_name, f'{name}.png'))] + input_frame_inds = sorted(set(input_frame_inds)) + for input_frame_idx in input_frame_inds: + (per_obj_input_mask, input_palette) = load_masks_from_dir(input_mask_dir=input_mask_dir, video_name=video_name, frame_name=frame_names[input_frame_idx], per_obj_png_file=per_obj_png_file) + for (object_id, object_mask) in per_obj_input_mask.items(): + predictor.add_new_mask(inference_state=inference_state, frame_idx=input_frame_idx, obj_id=object_id, mask=object_mask) + os.makedirs(os.path.join(output_mask_dir, video_name), exist_ok=True) + output_palette = input_palette or DAVIS_PALETTE + video_segments = {} + for (out_frame_idx, out_obj_ids, out_mask_logits) in predictor.propagate_in_video(inference_state): + per_obj_output_mask = {out_obj_id: (out_mask_logits[i] > score_thresh).cpu().numpy() for (i, out_obj_id) in enumerate(out_obj_ids)} + video_segments[out_frame_idx] = per_obj_output_mask + for (out_frame_idx, per_obj_output_mask) in video_segments.items(): + save_masks_to_dir(output_mask_dir=output_mask_dir, video_name=video_name, frame_name=frame_names[out_frame_idx], per_obj_output_mask=per_obj_output_mask, height=height, width=width, per_obj_png_file=per_obj_png_file, output_palette=output_palette) + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--sam2_cfg', type=str, default='sam2_hiera_b+.yaml', help='SAM 2 model configuration file') + parser.add_argument('--sam2_checkpoint', type=str, default='./checkpoints/sam2_hiera_b+.pt', help='path to the SAM 2 model checkpoint') + parser.add_argument('--base_video_dir', type=str, required=True, help='directory containing videos (as JPEG files) to run VOS prediction on') + parser.add_argument('--input_mask_dir', type=str, required=True, help='directory containing input masks (as PNG files) of each video') + parser.add_argument('--video_list_file', type=str, default=None, help='text file containing the list of video names to run VOS prediction on') + parser.add_argument('--output_mask_dir', type=str, required=True, help='directory to save the output masks (as PNG files)') + parser.add_argument('--score_thresh', type=float, default=0.0, help='threshold for the output mask logits (default: 0.0)') + parser.add_argument('--use_all_masks', action='store_true', help="whether to use all available PNG files in input_mask_dir (default without this flag: just the first PNG file as input to the SAM 2 model; usually we don't need this flag, since semi-supervised VOS evaluation usually takes input from the first frame only)") + parser.add_argument('--per_obj_png_file', action='store_true', help='whether use separate per-object PNG files for input and output masks (default without this flag: all object masks are packed into a single PNG file on each frame following DAVIS format; note that the SA-V dataset stores each object mask as an individual PNG file and requires this flag)') + parser.add_argument('--apply_postprocessing', action='store_true', help="whether to apply postprocessing (e.g. hole-filling) to the output masks (we don't apply such post-processing in the SAM 2 model evaluation)") + args = parser.parse_args() + hydra_overrides_extra = ['++model.non_overlap_masks=' + ('false' if args.per_obj_png_file else 'true')] + predictor = build_sam2_video_predictor(config_file=args.sam2_cfg, ckpt_path=args.sam2_checkpoint, apply_postprocessing=args.apply_postprocessing, hydra_overrides_extra=hydra_overrides_extra) + if args.use_all_masks: + print('using all available masks in input_mask_dir as input to the SAM 2 model') + else: + print("using only the first frame's mask in input_mask_dir as input to the SAM 2 model") + if args.video_list_file is not None: + with open(args.video_list_file, 'r') as f: + video_names = [v.strip() for v in f.readlines()] + else: + video_names = [p for p in os.listdir(args.base_video_dir) if os.path.isdir(os.path.join(args.base_video_dir, p))] + print(f'running VOS prediction on {len(video_names)} videos:\n{video_names}') + for (n_video, video_name) in enumerate(video_names): + print(f'\n{n_video + 1}/{len(video_names)} - running on {video_name}') + vos_inference(predictor=predictor, base_video_dir=args.base_video_dir, input_mask_dir=args.input_mask_dir, output_mask_dir=args.output_mask_dir, video_name=video_name, score_thresh=args.score_thresh, use_all_masks=args.use_all_masks, per_obj_png_file=args.per_obj_png_file) + print(f'completed VOS prediction on {len(video_names)} videos -- output masks saved to {args.output_mask_dir}') +if __name__ == '__main__': + main() +