Update README.md

README.md

@@ -1,199 +1,507 @@
 ---
+license: apache-2.0
+pipeline_tag: mask-generation
 library_name: transformers
-tags: []
 ---
+# Model Details
 
-# Model Card for Model ID
+[\[📃 Tech Report\]](https://arxiv.org/abs/2501.07256)
+[\[📂 Github\]](https://github.com/facebookresearch/EdgeTAM)
+[\[🤗 Demo\]](https://huggingface.co/spaces/yonigozlan/EdgeTAM-hf)
 
-<!-- Provide a quick summary of what the model is/does. -->
+EdgeTAM is an on-device executable variant of the SAM 2 for promptable segmentation and tracking in videos. It runs 22× faster than SAM 2 and achieves 16 FPS on iPhone 15 Pro Max without quantization.
 
+# How to use with Transformers
 
+### Automatic Mask Generation with Pipeline
 
-## Model Details
+EdgeTAM can be used for automatic mask generation to segment all objects in an image using the `mask-generation` pipeline:
 
-### Model Description
+```python
+>>> from transformers import pipeline
 
-<!-- Provide a longer summary of what this model is. -->
+>>> generator = pipeline("mask-generation", model="yonigozlan/EdgeTAM-hf", device=0)
+>>> image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
+>>> outputs = generator(image_url, points_per_batch=64)
 
-This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
+>>> len(outputs["masks"])  # Number of masks generated
+39
+```
 
-- **Developed by:** [More Information Needed]
-- **Funded by [optional]:** [More Information Needed]
-- **Shared by [optional]:** [More Information Needed]
-- **Model type:** [More Information Needed]
-- **Language(s) (NLP):** [More Information Needed]
-- **License:** [More Information Needed]
-- **Finetuned from model [optional]:** [More Information Needed]
+### Basic Image Segmentation
 
-### Model Sources [optional]
+#### Single Point Click
 
-<!-- Provide the basic links for the model. -->
+You can segment objects by providing a single point click on the object you want to segment:
 
-- **Repository:** [More Information Needed]
-- **Paper [optional]:** [More Information Needed]
-- **Demo [optional]:** [More Information Needed]
+```python
+>>> from transformers import Sam2Processor, EdgeTamModel
+>>> import torch
+>>> from PIL import Image
+>>> import requests
 
-## Uses
+>>> device = "cuda" if torch.cuda.is_available() else "cpu"
 
-<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+>>> model = EdgeTamModel.from_pretrained("yonigozlan/EdgeTAM-hf").to(device)
+>>> processor = Sam2Processor.from_pretrained("yonigozlan/EdgeTAM-hf")
 
-### Direct Use
+>>> image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
+>>> raw_image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")
 
-<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+>>> input_points = [[[[500, 375]]]]  # Single point click, 4 dimensions (image_dim, object_dim, point_per_object_dim, coordinates)
+>>> input_labels = [[[1]]]  # 1 for positive click, 0 for negative click, 3 dimensions (image_dim, object_dim, point_label)
 
-[More Information Needed]
+>>> inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
 
-### Downstream Use [optional]
+>>> with torch.no_grad():
+...     outputs = model(**inputs)
 
-<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+>>> masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
 
-[More Information Needed]
+>>> # The model outputs multiple mask predictions ranked by quality score
+>>> print(f"Generated {masks.shape[1]} masks with shape {masks.shape}")
+Generated 3 masks with shape torch.Size(1, 3, 1500, 2250)
+```
 
-### Out-of-Scope Use
+#### Multiple Points for Refinement
 
-<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+You can provide multiple points to refine the segmentation:
 
-[More Information Needed]
+```python
+>>> # Add both positive and negative points to refine the mask
+>>> input_points = [[[[500, 375], [1125, 625]]]]  # Multiple points for refinement
+>>> input_labels = [[[1, 1]]]  # Both positive clicks
 
-## Bias, Risks, and Limitations
+>>> inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
 
-<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+>>> with torch.no_grad():
+...     outputs = model(**inputs)
 
-[More Information Needed]
+>>> masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
+```
 
-### Recommendations
+#### Bounding Box Input
 
-<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+EdgeTAM also supports bounding box inputs for segmentation:
 
-Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+```python
+>>> # Define bounding box as [x_min, y_min, x_max, y_max]
+>>> input_boxes = [[[75, 275, 1725, 850]]]
 
-## How to Get Started with the Model
+>>> inputs = processor(images=raw_image, input_boxes=input_boxes, return_tensors="pt").to(device)
 
-Use the code below to get started with the model.
+>>> with torch.no_grad():
+...     outputs = model(**inputs)
 
-[More Information Needed]
+>>> masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
+```
 
-## Training Details
+#### Multiple Objects Segmentation
 
-### Training Data
+You can segment multiple objects simultaneously:
 
-<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+```python
+>>> # Define points for two different objects
+>>> input_points = [[[[500, 375]], [[650, 750]]]]  # Points for two objects in same image
+>>> input_labels = [[[1], [1]]]  # Positive clicks for both objects
 
-[More Information Needed]
+>>> inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
 
-### Training Procedure
+>>> with torch.no_grad():
+...     outputs = model(**inputs, multimask_output=False)
 
-<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+>>> # Each object gets its own mask
+>>> masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
+>>> print(f"Generated masks for {masks.shape[0]} objects")
+Generated masks for 2 objects
+```
 
-#### Preprocessing [optional]
+### Batch Inference
 
-[More Information Needed]
+#### Batched Images
 
+Process multiple images simultaneously for improved efficiency:
 
-#### Training Hyperparameters
+```python
+>>> from transformers import Sam2Processor, EdgeTamModel
+>>> import torch
+>>> from PIL import Image
+>>> import requests
 
-- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+>>> device = "cuda" if torch.cuda.is_available() else "cpu"
 
-#### Speeds, Sizes, Times [optional]
+>>> model = EdgeTamModel.from_pretrained("yonigozlan/EdgeTAM-hf").to(device)
+>>> processor = Sam2Processor.from_pretrained("yonigozlan/EdgeTAM-hf")
 
-<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+>>> # Load multiple images
+>>> image_urls = [
+...     "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg",
+...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/dog-sam.png"
+... ]
+>>> raw_images = [Image.open(requests.get(url, stream=True).raw).convert("RGB") for url in image_urls]
 
-[More Information Needed]
+>>> # Single point per image
+>>> input_points = [[[[500, 375]]], [[[770, 200]]]]  # One point for each image
+>>> input_labels = [[[1]], [[1]]]  # Positive clicks for both images
 
-## Evaluation
+>>> inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
 
-<!-- This section describes the evaluation protocols and provides the results. -->
+>>> with torch.no_grad():
+...     outputs = model(**inputs, multimask_output=False)
 
-### Testing Data, Factors & Metrics
+>>> # Post-process masks for each image
+>>> all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
+>>> print(f"Processed {len(all_masks)} images, each with {all_masks[0].shape[0]} objects")
+Processed 2 images, each with 1 objects
+```
 
-#### Testing Data
+#### Batched Objects per Image
 
-<!-- This should link to a Dataset Card if possible. -->
+Segment multiple objects within each image using batch inference:
 
-[More Information Needed]
+```python
+>>> # Multiple objects per image - different numbers of objects per image
+>>> input_points = [
+...     [[[500, 375]], [[650, 750]]],  # Truck image: 2 objects
+...     [[[770, 200]]]  # Dog image: 1 object
+... ]
+>>> input_labels = [
+...     [[1], [1]],  # Truck image: positive clicks for both objects
+...     [[1]]  # Dog image: positive click for the object
+... ]
 
-#### Factors
+>>> inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
 
-<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+>>> with torch.no_grad():
+...     outputs = model(**inputs, multimask_output=False)
 
-[More Information Needed]
+>>> all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
+```
 
-#### Metrics
+#### Batched Images with Batched Objects and Multiple Points
 
-<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+Handle complex batch scenarios with multiple points per object:
 
-[More Information Needed]
+```python
+>>> # Add groceries image for more complex example
+>>> groceries_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/groceries.jpg"
+>>> groceries_image = Image.open(requests.get(groceries_url, stream=True).raw).convert("RGB")
+>>> raw_images = [raw_images[0], groceries_image]  # Use truck and groceries images
 
-### Results
+>>> # Complex batching: multiple images, multiple objects, multiple points per object
+>>> input_points = [
+...     [[[500, 375]], [[650, 750]]],  # Truck image: 2 objects with 1 point each
+...     [[[400, 300]], [[630, 300], [550, 300]]]  # Groceries image: obj1 has 1 point, obj2 has 2 points
+... ]
+>>> input_labels = [
+...     [[1], [1]],  # Truck image: positive clicks
+...     [[1], [1, 1]]  # Groceries image: positive clicks for refinement
+... ]
 
-[More Information Needed]
+>>> inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
 
-#### Summary
+>>> with torch.no_grad():
+...     outputs = model(**inputs, multimask_output=False)
 
+>>> all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
+```
 
+#### Batched Bounding Boxes
 
-## Model Examination [optional]
+Process multiple images with bounding box inputs:
 
-<!-- Relevant interpretability work for the model goes here -->
-
-[More Information Needed]
-
-## Environmental Impact
-
-<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
-
-Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
-
-- **Hardware Type:** [More Information Needed]
-- **Hours used:** [More Information Needed]
-- **Cloud Provider:** [More Information Needed]
-- **Compute Region:** [More Information Needed]
-- **Carbon Emitted:** [More Information Needed]
-
-## Technical Specifications [optional]
-
-### Model Architecture and Objective
-
-[More Information Needed]
-
-### Compute Infrastructure
-
-[More Information Needed]
-
-#### Hardware
-
-[More Information Needed]
-
-#### Software
-
-[More Information Needed]
-
-## Citation [optional]
-
-<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
-
-**BibTeX:**
-
-[More Information Needed]
-
-**APA:**
-
-[More Information Needed]
-
-## Glossary [optional]
-
-<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
-
-[More Information Needed]
-
-## More Information [optional]
-
-[More Information Needed]
-
-## Model Card Authors [optional]
-
-[More Information Needed]
-
-## Model Card Contact
-
-[More Information Needed]
+```python
+>>> # Multiple bounding boxes per image (using truck and groceries images)
+>>> input_boxes = [
+...     [[75, 275, 1725, 850], [425, 600, 700, 875], [1375, 550, 1650, 800], [1240, 675, 1400, 750]],  # Truck image: 4 boxes
+...     [[450, 170, 520, 350], [350, 190, 450, 350], [500, 170, 580, 350], [580, 170, 640, 350]]  # Groceries image: 4 boxes
+... ]
+
+>>> # Update images for this example
+>>> raw_images = [raw_images[0], groceries_image]  # truck and groceries
+
+>>> inputs = processor(images=raw_images, input_boxes=input_boxes, return_tensors="pt").to(device)
+
+>>> with torch.no_grad():
+...     outputs = model(**inputs, multimask_output=False)
+
+>>> all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
+>>> print(f"Processed {len(input_boxes)} images with {len(input_boxes[0])} and {len(input_boxes[1])} boxes respectively")
+Processed 2 images with 4 and 4 boxes respectively
+```
+
+### Using Previous Masks as Input
+
+EdgeTAM can use masks from previous predictions as input to refine segmentation:
+
+```python
+>>> # Get initial segmentation
+>>> input_points = [[[[500, 375]]]]
+>>> input_labels = [[[1]]]
+>>> inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
+
+>>> with torch.no_grad():
+...     outputs = model(**inputs)
+
+>>> # Use the best mask as input for refinement
+>>> mask_input = outputs.pred_masks[:, :, torch.argmax(outputs.iou_scores.squeeze())]
+
+>>> # Add additional points with the mask input
+>>> new_input_points = [[[[500, 375], [450, 300]]]]
+>>> new_input_labels = [[[1, 1]]]
+>>> inputs = processor(
+...     input_points=new_input_points,
+...     input_labels=new_input_labels,
+...     original_sizes=inputs["original_sizes"],
+...     return_tensors="pt",
+... ).to(device)
+
+>>> with torch.no_grad():
+...     refined_outputs = model(
+...         **inputs,
+...         input_masks=mask_input,
+...         image_embeddings=outputs.image_embeddings,
+...         multimask_output=False,
+...     )
+```
+
+
+### Video Segmentation and Tracking
+
+EdgeTAM's key strength is its ability to track objects across video frames. Here's how to use it for video segmentation:
+
+#### Basic Video Tracking
+
+```python
+>>> from transformers import EdgeTamVideoModel, Sam2VideoProcessor
+>>> import torch
+
+>>> device = "cuda" if torch.cuda.is_available() else "cpu"
+>>> model = EdgeTamVideoModel.from_pretrained("yonigozlan/EdgeTAM-hf").to(device, dtype=torch.bfloat16)
+>>> processor = Sam2VideoProcessor.from_pretrained("yonigozlan/EdgeTAM-hf")
+
+>>> # Load video frames (example assumes you have a list of PIL Images)
+>>> # video_frames = [Image.open(f"frame_{i:05d}.jpg") for i in range(num_frames)]
+
+>>> # For this example, we'll use the video loading utility
+>>> from transformers.video_utils import load_video
+>>> video_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/bedroom.mp4"
+>>> video_frames, _ = load_video(video_url)
+
+>>> # Initialize video inference session
+>>> inference_session = processor.init_video_session(
+...     video=video_frames,
+...     inference_device=device,
+...     torch_dtype=torch.bfloat16,
+... )
+
+>>> # Add click on first frame to select object
+>>> ann_frame_idx = 0
+>>> ann_obj_id = 1
+>>> points = [[[[210, 350]]]]
+>>> labels = [[[1]]]
+
+>>> processor.add_inputs_to_inference_session(
+...     inference_session=inference_session,
+...     frame_idx=ann_frame_idx,
+...     obj_ids=ann_obj_id,
+...     input_points=points,
+...     input_labels=labels,
+... )
+
+>>> # Segment the object on the first frame
+>>> outputs = model(
+...     inference_session=inference_session,
+...     frame_idx=ann_frame_idx,
+... )
+>>> video_res_masks = processor.post_process_masks(
+...     [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
+... )[0]
+>>> print(f"Segmentation shape: {video_res_masks.shape}")
+Segmentation shape: torch.Size([1, 1, 480, 854])
+
+>>> # Propagate through the entire video
+>>> video_segments = {}
+>>> for edgetam_video_output in model.propagate_in_video_iterator(inference_session):
+...     video_res_masks = processor.post_process_masks(
+...         [edgetam_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
+...     )[0]
+...     video_segments[edgetam_video_output.frame_idx] = video_res_masks
+
+>>> print(f"Tracked object through {len(video_segments)} frames")
+Tracked object through 180 frames
+```
+
+#### Multi-Object Video Tracking
+
+Track multiple objects simultaneously across video frames:
+
+```python
+>>> # Reset for new tracking session
+>>> inference_session.reset_inference_session()
+
+>>> # Add multiple objects on the first frame
+>>> ann_frame_idx = 0
+>>> obj_ids = [2, 3]
+>>> input_points = [[[[200, 300]], [[400, 150]]]]  # Points for two objects (batched)
+>>> input_labels = [[[1], [1]]]
+
+>>> processor.add_inputs_to_inference_session(
+...     inference_session=inference_session,
+...     frame_idx=ann_frame_idx,
+...     obj_ids=obj_ids,
+...     input_points=input_points,
+...     input_labels=input_labels,
+... )
+
+>>> # Get masks for both objects on first frame
+>>> outputs = model(
+...     inference_session=inference_session,
+...     frame_idx=ann_frame_idx,
+... )
+
+>>> # Propagate both objects through video
+>>> video_segments = {}
+>>> for edgetam_video_output in model.propagate_in_video_iterator(inference_session):
+...     video_res_masks = processor.post_process_masks(
+...         [edgetam_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
+...     )[0]
+...     video_segments[edgetam_video_output.frame_idx] = {
+...         obj_id: video_res_masks[i]
+...         for i, obj_id in enumerate(inference_session.obj_ids)
+...     }
+
+>>> print(f"Tracked {len(inference_session.obj_ids)} objects through {len(video_segments)} frames")
+Tracked 2 objects through 180 frames
+```
+
+#### Refining Video Segmentation
+
+You can add additional clicks on any frame to refine the tracking:
+
+```python
+>>> # Add refinement click on a later frame
+>>> refine_frame_idx = 50
+>>> ann_obj_id = 2  # Refining first object
+>>> points = [[[[220, 280]]]]  # Additional point
+>>> labels = [[[1]]]  # Positive click
+
+>>> processor.add_inputs_to_inference_session(
+...     inference_session=inference_session,
+...     frame_idx=refine_frame_idx,
+...     obj_ids=ann_obj_id,
+...     input_points=points,
+...     input_labels=labels,
+... )
+
+>>> # Re-propagate with the additional information
+>>> video_segments = {}
+>>> for edgetam_video_output in model.propagate_in_video_iterator(inference_session):
+...     video_res_masks = processor.post_process_masks(
+...         [edgetam_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
+...     )[0]
+...     video_segments[edgetam_video_output.frame_idx] = video_res_masks
+```
+
+### Streaming Video Inference
+
+For real-time applications, EdgeTAM supports processing video frames as they arrive:
+
+```python
+>>> # Initialize session for streaming
+>>> inference_session = processor.init_video_session(
+...     inference_device=device,
+...     torch_dtype=torch.bfloat16,
+... )
+
+>>> # Process frames one by one
+>>> for frame_idx, frame in enumerate(video_frames[:10]):  # Process first 10 frames
+...     inputs = processor(images=frame, device=device, return_tensors="pt")
+...
+...     if frame_idx == 0:
+...         # Add point input on first frame
+...         processor.add_inputs_to_inference_session(
+...             inference_session=inference_session,
+...             frame_idx=0,
+...             obj_ids=1,
+...             input_points=[[[[210, 350], [250, 220]]]],
+...             input_labels=[[[1, 1]]],
+...             original_size=inputs.original_sizes[0], # need to be provided when using streaming video inference
+...         )
+...
+...     # Process current frame
+...     edgetam_video_output = model(inference_session=inference_session, frame=inputs.pixel_values[0])
+...
+...     video_res_masks = processor.post_process_masks(
+...         [edgetam_video_output.pred_masks], original_sizes=inputs.original_sizes, binarize=False
+...     )[0]
+...     print(f"Frame {frame_idx}: mask shape {video_res_masks.shape}")
+```
+
+#### Video Batch Processing for Multiple Objects
+
+Track multiple objects simultaneously in video by adding them all at once:
+
+```python
+>>> # Initialize video session
+>>> inference_session = processor.init_video_session(
+...     video=video_frames,
+...     inference_device=device,
+...     torch_dtype=torch.bfloat16,
+... )
+
+>>> # Add multiple objects on the first frame using batch processing
+>>> ann_frame_idx = 0
+>>> obj_ids = [2, 3]  # Track two different objects
+>>> input_points = [
+...     [[[200, 300], [230, 250], [275, 175]], [[400, 150]]]
+... ]  # Object 2: 3 points (2 positive, 1 negative); Object 3: 1 point
+>>> input_labels = [
+...     [[1, 1, 0], [1]]
+... ]  # Object 2: positive, positive, negative; Object 3: positive
+
+>>> processor.add_inputs_to_inference_session(
+...     inference_session=inference_session,
+...     frame_idx=ann_frame_idx,
+...     obj_ids=obj_ids,
+...     input_points=input_points,
+...     input_labels=input_labels,
+... )
+
+>>> # Get masks for all objects on the first frame
+>>> outputs = model(
+...     inference_session=inference_session,
+...     frame_idx=ann_frame_idx,
+... )
+>>> video_res_masks = processor.post_process_masks(
+...     [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
+... )[0]
+>>> print(f"Generated masks for {video_res_masks.shape[0]} objects")
+Generated masks for 2 objects
+
+>>> # Propagate all objects through the video
+>>> video_segments = {}
+>>> for edgetam_video_output in model.propagate_in_video_iterator(inference_session):
+...     video_res_masks = processor.post_process_masks(
+...         [edgetam_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
+...     )[0]
+...     video_segments[edgetam_video_output.frame_idx] = {
+...         obj_id: video_res_masks[i]
+...         for i, obj_id in enumerate(inference_session.obj_ids)
+...     }
+
+>>> print(f"Tracked {len(inference_session.obj_ids)} objects through {len(video_segments)} frames")
+Tracked 2 objects through 180 frames
+```
+
+# Citation
+If you find our code useful for your research, please consider citing:
+
+```
+@article{zhou2025edgetam,
+  title={EdgeTAM: On-Device Track Anything Model},
+  author={Zhou, Chong and Zhu, Chenchen and Xiong, Yunyang and Suri, Saksham and Xiao, Fanyi and Wu, Lemeng and Krishnamoorthi, Raghuraman and Dai, Bo and Loy, Chen Change and Chandra, Vikas and Soran, Bilge},
+  journal={arXiv preprint arXiv:2501.07256},
+  year={2025}
+}
+```