No module named 'triton' on Mac

[YueChengPeng]

I am trying to run SAM3 on MacOS (M1pro chip), but I encountered a ModuleNotFoundError: No module named 'triton' when importing the model.

ModuleNotFoundError Traceback (most recent call last)
Cell In[4], line 8
6 #################################### For Image ####################################
7 from PIL import Image
----> 8 from sam3.model_builder import build_sam3_image_model
9 from sam3.model.sam3_image_processor import Sam3Processor
10 # Load the model

File ~/Develop/chat w printer/app/vendor/sam3/sam3/init.py:3
1 # Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
----> 3 from .model_builder import build_sam3_image_model
5 version = "0.1.0"
7 all = ["build_sam3_image_model"]

File ~/Develop/chat w printer/app/vendor/sam3/sam3/model_builder.py:33
31 from sam3.model.necks import Sam3DualViTDetNeck
32 from sam3.model.position_encoding import PositionEmbeddingSine
---> 33 from sam3.model.sam1_task_predictor import SAM3InteractiveImagePredictor
34 from sam3.model.sam3_image import Sam3Image, Sam3ImageOnVideoMultiGPU
35 from sam3.model.sam3_tracking_predictor import Sam3TrackerPredictor

File ~/Develop/chat w printer/app/vendor/sam3/sam3/model/sam1_task_predictor.py:17
14 import torch.nn as nn
15 from PIL.Image import Image
...
(...)
49
50 """

ModuleNotFoundError: No module named 'triton'

[ayushpythonista]

I am also facing this issue on MAC, any resolution please

[benjaminleroy]

I used github copilot/claude sonnet 4.5 to fix this issue for me. Attached is a summary of detailed fixes. In general, you'll find that both triton and decord are not found for mac. Additionally, the code contains hard-coded device = "cuda" instead of passing it in (and there encoder memory issue that is also associated with "cuda" vs "cpu").

Also, if anyone has more bandwidth you could recommend some of these updates in a PR.

---

macOS Compatibility Changes for SAM3

This document details all the changes made to enable SAM3 to run on macOS (Apple Silicon) without CUDA support.

Overview

SAM3 was originally designed to run on Linux with CUDA GPUs. Several modifications were necessary to make it compatible with macOS, which lacks CUDA support and has different available packages (like Triton and decord that don't have macOS wheels).

Dependency Changes

1. NumPy Version Constraint (pyproject.toml)

File: pyproject.toml
Line: 28

Change:

- "numpy==1.26",
+ "numpy>=2.0",

Reason: NumPy 1.26.0 requires building from source on macOS with Python 3.14, which fails due to missing BLAS libraries. NumPy 2.0+ has pre-built wheels for macOS ARM64.

2. Added Required Dependencies (pyproject.toml)

Lines: 37-39

Added:

"scipy",
"pycocotools",
"psutil",
"opencv-python",

Reason: These dependencies were missing from the main dependencies list but are required by the codebase. They were previously only in optional dependency groups.

Code Changes for Optional Triton Support

3. Conditional Triton Import (sam3/model/edt.py)

Lines: 1-15

Change:

# Original:
import torch
import triton
import triton.language as tl

# Modified:
import torch

# Try to import triton, but provide fallback for macOS and other platforms
try:
    import triton
    import triton.language as tl
    HAS_TRITON = True
except (ImportError, ModuleNotFoundError):
    HAS_TRITON = False
    triton = None
    tl = None

Reason: Triton is a CUDA-only library and doesn't have macOS wheels. This makes the import optional.

4. Conditional Triton Kernel Definition (sam3/model/edt.py)

Lines: 60-123

Change:

# Wrapped the entire edt_kernel function in a conditional block:
if HAS_TRITON:
    @triton.jit
    def edt_kernel(inputs_ptr, outputs_ptr, v, z, height, width, horizontal: tl.constexpr):
        # ... (entire function body indented)

Reason: The Triton kernel can only be defined if Triton is available. All kernel code is now inside the conditional block.

5. CPU Fallback for EDT (sam3/model/edt.py)

Lines: 125-138 and 187-219

Change:

def edt_triton(data: torch.Tensor):
    """..."""
    # Added at the beginning:
    if not HAS_TRITON or not data.is_cuda:
        return edt_cpu_fallback(data)
    
    # ... rest of CUDA/Triton implementation

# Added new function:
def edt_cpu_fallback(data: torch.Tensor):
    """
    CPU fallback for EDT using scipy's distance_transform_edt.
    Used when Triton is not available (e.g., on macOS).
    """
    try:
        from scipy.ndimage import distance_transform_edt
    except ImportError:
        raise ImportError(
            "scipy is required for CPU EDT fallback. "
            "Install with: pip install scipy"
        )
    
    assert data.dim() == 3
    B, H, W = data.shape
    
    # Move to CPU if on GPU
    device = data.device
    data_cpu = data.cpu().numpy()
    
    # Compute EDT for each image in batch
    output = torch.zeros_like(data, dtype=torch.float32)
    for i in range(B):
        # Invert: 1 -> 0, 0 -> 1 for scipy
        inverted = 1 - data_cpu[i]
        edt_result = distance_transform_edt(inverted)
        output[i] = torch.from_numpy(edt_result)
    
    # Move back to original device
    return output.to(device)

Reason: Provides a scipy-based implementation of Euclidean Distance Transform when Triton is not available.

Code Changes for Optional Decord Support

6. Conditional Decord Import (sam3/train/data/sam3_image_dataset.py)

Lines: 15-27

Change:

# Original:
import torch
import torch.utils.data
import torchvision
from decord import cpu, VideoReader
from iopath.common.file_io import g_pathmgr

# Modified:
import torch
import torch.utils.data
import torchvision

# Conditional import for decord (not available on macOS)
try:
    from decord import cpu, VideoReader
    HAS_DECORD = True
except (ImportError, ModuleNotFoundError):
    HAS_DECORD = False
    VideoReader = None
    cpu = None

from iopath.common.file_io import g_pathmgr

Reason: Decord doesn't have macOS wheels. Making it optional allows the core functionality to work without it.

Device Compatibility Changes

7. Position Encoding Device Detection (sam3/model/position_encoding.py)

Lines: 35-51

Change:

# Original (line 47):
tensors = torch.zeros((1, 1) + size, device="cuda")

# Modified (lines 46-48):
# Use CPU for precompute if CUDA is not available
device = "cuda" if torch.cuda.is_available() else "cpu"
tensors = torch.zeros((1, 1) + size, device=device)

Reason: Hardcoded "cuda" device caused crashes on macOS. Now auto-detects available device.

8. Decoder Coordinates Device Detection (sam3/model/decoder.py)

Lines: 275-284

Change:

# Original (line 280):
coords_h, coords_w = self._get_coords(
    feat_size, feat_size, device="cuda"
)

# Modified (lines 279-282):
# Use CPU if CUDA is not available
device = "cuda" if torch.cuda.is_available() else "cpu"
coords_h, coords_w = self._get_coords(
    feat_size, feat_size, device=device
)

Reason: Another hardcoded "cuda" device that needed auto-detection.

9. Image Processor Device Default (sam3/model/sam3_image_processor.py)

Lines: 17-21

Change:

# Original:
def __init__(self, model, resolution=1008, device="cuda", confidence_threshold=0.5):
    self.model = model
    self.resolution = resolution
    self.device = device

# Modified:
def __init__(self, model, resolution=1008, device=None, confidence_threshold=0.5):
    if device is None:
        device = "cuda" if torch.cuda.is_available() else "cpu"
    self.model = model
    self.resolution = resolution
    self.device = device

Reason: Changed default from hardcoded "cuda" to auto-detection.

10. VL Combiner Device Defaults (sam3/model/vl_combiner.py)

Lines: 121-124 and 133-140

Change:

# Original (line 122):
def forward_text(
    self, captions, input_boxes=None, additional_text=None, device="cuda"
):

# Modified (lines 122-124):
def forward_text(
    self, captions, input_boxes=None, additional_text=None, device=None
):
    if device is None:
        device = "cuda" if torch.cuda.is_available() else "cpu"

# Similar change for _forward_text_no_ack_ckpt (lines 133-140)

Reason: Multiple functions with hardcoded "cuda" device parameters needed auto-detection.

11. Geometry Encoder Pin Memory Fix (sam3/model/geometry_encoders.py)

Lines: 655-663

Change:

# Original:
scale = torch.tensor([W, H, W, H], dtype=boxes_xyxy.dtype)
scale = scale.pin_memory().to(device=boxes_xyxy.device, non_blocking=True)
scale = scale.view(1, 1, 4)

# Modified:
scale = torch.tensor([W, H, W, H], dtype=boxes_xyxy.dtype)
# Only pin memory for CUDA, not for MPS or CPU
if boxes_xyxy.device.type == "cuda":
    scale = scale.pin_memory().to(device=boxes_xyxy.device, non_blocking=True)
else:
    scale = scale.to(device=boxes_xyxy.device)
scale = scale.view(1, 1, 4)

Reason: .pin_memory() is CUDA-specific and causes device mismatch errors on MPS (Apple Silicon GPU) or CPU. Now only uses pin_memory for CUDA devices.

Script Changes

12. Human Mesh Pipeline Device Detection (scripts/human_mesh_pipeline.py) <- the script I use to run the model.

Lines: 24-36

Change:

# Determine device
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")

# Load the model
print("Loading SAM3 model...")
model = build_sam3_image_model(device=device)

Reason: Ensures the script uses the correct device and provides feedback to the user.

Summary

These changes enable SAM3 to run on macOS by:

1. Making platform-specific dependencies optional (Triton, decord)
2. Providing CPU fallbacks where needed (scipy for EDT)
3. Auto-detecting available compute devices instead of hardcoding "cuda"
4. Fixing device-specific operations (pin_memory) to work across CUDA, MPS, and CPU
5. Updating dependency constraints to use pre-built wheels

The model now successfully loads and runs on macOS CPU (and should work on Apple Silicon MPS as well), albeit more slowly than on CUDA GPUs.

[Joeycho]

#209

[muhammad-fiaz]

PR #403