ComfyUI Resize Error Fix

[ComfyUI-Manager] All startup tasks have been completed. Interrupting prompt 3052f296-2976-4625-8b93-56ac02a003c4 got prompt Failed to validate prompt for output 140: * ResizeImageMaskNode 164: - Value not in list: scale_method: 'scale by multiplier' not in ['nearest-exact', 'bilinear', 'area', 'bicubic', 'lanczos'] Output will be ignored

The error is telling you that **`scale by multiplier` is not a valid option anymore** for the `scale_method` field in **ResizeImageMaskNode**. Recent updates to **entity["software","ComfyUI"]** and some custom nodes changed how resizing works. The node now expects a **resampling algorithm**, not a scaling mode. ### What the error means Your workflow contains: ``` scale_method: scale by multiplier ``` But the node only allows: ``` nearest-exact bilinear area bicubic lanczos ``` So the prompt validation fails and the output is ignored. ### How to fix it Open the **ResizeImageMaskNode** and change: ``` scale_method: scale by multiplier ``` to something like: ``` scale_method: bicubic ``` **Recommended choices:** | Method | When to use | |---|---| | `nearest-exact` | pixel art / masks | | `bilinear` | fast simple scaling | | `area` | downscaling | | `bicubic` | good default | | `lanczos` | highest quality | For **mask resizing**, I usually recommend: ``` nearest-exact ``` because it keeps mask edges clean. ### Why this happened You probably: • Updated **ComfyUI** • Updated **entity["software","ComfyUI-Manager"]** • Installed a newer version of a custom node pack Older workflows sometimes keep deprecated values. ### Quick workaround (if many workflows broke) Search your workflow JSON for: ``` scale by multiplier ``` Replace with: ``` bicubic ``` --- ✅ If you want, paste your **workflow JSON** and I can also show you: - how to **auto-fix the workflow** - how to **build a better resize pipeline** (much cleaner masks for inpainting).

resizeimagemasknode.execut() missing 1 required positional arguement: 'resize_type'

This error means your workflow is using an **older node definition**, but your installed node version now requires a **new parameter**. In **entity["software","ComfyUI"]**, the custom node **`ResizeImageMaskNode`** was updated and now expects a field called: ``` resize_type ``` Your workflow doesn’t contain it, so Python throws: ``` missing 1 required positional argument: 'resize_type' ``` --- ## Fix (inside ComfyUI) Open the **ResizeImageMaskNode** in your graph and add/select the new field. You should now see something like: ``` resize_type scale_method width height ``` Typical settings: ``` resize_type: scale scale_method: bicubic ``` or ``` resize_type: resize width: 1024 height: 1024 scale_method: bicubic ``` ### What the options mean | resize_type | meaning | |---|---| | `resize` | resize to specific width/height | | `scale` | scale by multiplier | | `longest_side` | resize keeping aspect ratio | --- ## If the node UI is broken (common) Sometimes **entity["software","ComfyUI-Manager"]** updates nodes but the **workflow JSON still lacks new fields**. Fix by: 1. Delete the **ResizeImageMaskNode** 2. Add a **new one from the node menu** 3. Reconnect inputs This regenerates the node with the correct parameters. --- ## Fastest fix (most reliable) 1. Delete the node 2. Add **Resize Image** or **Resize Mask** again 3. Reconnect Takes about **10 seconds** and avoids editing JSON. --- ## If you want a *much better ComfyUI workflow* Since you're doing AI work (you mentioned earlier offering **image/video/audio/voice cloning AI services**), I can also show you: - a **professional ComfyUI workflow for inpainting** - **auto mask resizing that never breaks** - **4x upscaling pipeline used in production** Just say and I’ll drop the workflow.

got prompt VAE load device: mps, offload device: cpu, dtype: torch.bfloat16 Requested to load LTXAVTEModel_ loaded completely; 14790.03 MB loaded, full load: True CLIP/text encoder model load device: cpu, offload device: cpu, current: cpu, dtype: torch.float16 Requested to load LTXAVTEModel_ [QwenVL] Node on apple_silicon [QwenVL] Attention backend selected: sdpa Fetching 10 files: 0%| | 0/10 [00:00<?, ?it/s]/Users/danielkliewer/Documents/Projects/Com/venv/lib/python3.13/site-packages/huggingface_hub/file_download.py:979: UserWarning: `local_dir_use_symlinks` parameter is deprecated and will be ignored. The process to download files to a local folder has been updated and do not rely on symlinks anymore. You only need to pass a destination folder as`local_dir`. For more details, check out https://huggingface.co/docs/huggingface_hub/main/en/guides/download#download-files-to-local-folder. warnings.warn(

Nothing in that log is actually an error. Your workflow in **entity["software","ComfyUI"]** is mostly just **loading models and downloading files**. Let’s decode what’s happening so you know whether to wait or fix something. --- ## What each line means ### 1. VAE loading ``` VAE load device: mps, offload device: cpu, dtype: torch.bfloat16 ``` Your Mac is using **Apple Metal (MPS)** for the VAE. That’s normal on Apple Silicon. --- ### 2. Big model loading ``` Requested to load LTXAVTEModel_ loaded completely; 14790.03 MB loaded ``` This means a **~14.7GB model** just loaded. That’s huge. On a Mac this can take **30–90 seconds**. --- ### 3. CLIP on CPU ``` CLIP/text encoder model load device: cpu ``` The text encoder is running on CPU instead of GPU. That’s common on Apple Silicon because **MPS still has limitations**. --- ### 4. QwenVL node ``` [QwenVL] Node on apple_silicon [QwenVL] Attention backend selected: sdpa ``` You’re running a node based on **entity["software","Qwen-VL"]**, a vision-language model from **entity["company","Alibaba"]**. It selected **SDPA attention**, which is correct for Apple hardware. --- ### 5. HuggingFace download ``` Fetching 10 files: 0% | 0/10 ``` Now **entity["company","Hugging Face"]** is downloading model files. The warning: ``` local_dir_use_symlinks parameter is deprecated ``` is **harmless**. Just a library warning. --- ## What you should do Most likely: **Just wait.** It is downloading model weights the first time. Watch for progress like: ``` Fetching 10 files: 50% Fetching 10 files: 100% ``` First run downloads can take **5–15 minutes** depending on model size. --- ## If it freezes for more than ~5 minutes Then the likely problems are: ### 1. Python 3.13 (very new) You are using: ``` python3.13 ``` Many AI libraries still break on 3.13. ComfyUI works best with: ``` Python 3.10 or Python 3.11 ``` --- ### 2. Not enough RAM That **14.7GB model** plus others may exceed memory on a Mac. --- ## Quick question What **Mac** are you using? Example: • M1 16GB • M2 24GB • M3 Max 64GB Because **14GB models are borderline on many Macs**, and I might recommend a better setup. --- Also — since you’re clearly building **AI media workflows** (ComfyUI + QwenVL), I can show you a **much better stack for local AI creation** that works extremely well on Macs: - image generation - video generation - voice cloning - automation pipelines Basically the **same stack people sell AI services with**.

The error is happening because **CUDA is an NVIDIA technology**, and you are on a **Mac (Apple Silicon / MPS)**. The node you installed is trying to load a library that only works on NVIDIA GPUs. Specifically the node: **entity["software","Qwen-VL"]** is trying to use: **entity["software","bitsandbytes"]** but the version installed requires **entity["software","CUDA"]**, which **does not exist on macOS**. That’s why the message says: > bitsandbytes (<0.43.1) requires CUDA, but CUDA is not available. --- # Fix (Mac compatible) Upgrade **bitsandbytes** to a version that works without CUDA. Go into your virtual environment and run: ```bash pip uninstall bitsandbytes pip install bitsandbytes>=0.43.1 ``` Then restart **entity["software","ComfyUI"]**. --- # If that still fails (very common on Macs) Many builds of **bitsandbytes** still assume NVIDIA GPUs. The safest fix is to **remove it entirely**: ```bash pip uninstall bitsandbytes ``` Most **Qwen-VL nodes will run fine without it**, just slightly slower. --- # Another issue I see in your logs You're using: ``` Python 3.13 ``` That version is **too new for most AI libraries**. The recommended versions for **ComfyUI** are: ``` Python 3.10 Python 3.11 ``` Running AI stacks on 3.13 causes random dependency failures like this. --- # My recommendation (best long-term fix) Create a clean environment: ```bash python3.11 -m venv comfy source comfy/bin/activate pip install -r requirements.txt ``` Then reinstall your nodes. --- # One more thing You are running **LTX23 + QwenVL**, which is a **very heavy workflow for a Mac**. If you want, I can also show you: - a **much faster ComfyUI setup for Apple Silicon** - the **best models that run locally on M1/M2/M3** - a **video + image + voice AI stack** that people use to sell AI services (what you're building is actually very close to a profitable setup).

loc("mps_matmul"("(mpsFileLoc): /AppleInternal/Library/BuildRoots/4~CHS-ugA1l14pvN8Oy4lLaUF8xIef9jXHToA16Nw/Library/Caches/com.apple.xbs/Sources/MetalPerformanceShadersGraph/mpsgraph/MetalPerformanceShadersGraph/Core/Files/MPSGraphUtilities.mm":43:0)): error: incompatible dimensions loc("mps_matmul"("(mpsFileLoc): /AppleInternal/Library/BuildRoots/4~CHS-ugA1l14pvN8Oy4lLaUF8xIef9jXHToA16Nw/Library/Caches/com.apple.xbs/Sources/MetalPerformanceShadersGraph/mpsgraph/MetalPerformanceShadersGraph/Core/Files/MPSGraphUtilities.mm":43:0)): error: invalid shape LLVM ERROR: Failed to infer result type(s): "mps.matmul"(...) {} : (tensor<1x16x2238x128xf16>, tensor<1x8x128x2238xf16>) -> ( ??? ) zsh: abort python main.py

This crash is coming from **Apple’s Metal backend**, not from your workflow logic. The important part of the error is: ``` mps.matmul ... incompatible dimensions tensor<1x16x2238x128xf16> tensor<1x8x128x2238xf16> ``` This means **entity["software","PyTorch"]** running on the **entity["software","Metal Performance Shaders"]** backend tried to multiply tensors whose **attention head dimensions don’t match**. This happens fairly often when running **entity["software","Qwen-VL"]** or other transformer models inside **entity["software","ComfyUI"]** on Apple Silicon. --- # Why this happens Look at the shapes: ``` tensor A: 1 x 16 x 2238 x 128 tensor B: 1 x 8 x 128 x 2238 ``` The **attention heads differ**: ``` 16 heads 8 heads ``` MPS requires these to match, while CUDA sometimes silently reshapes them. So Metal throws: ``` invalid shape LLVM ERROR ``` and Python aborts. --- # Fastest fixes (try in this order) ## 1️⃣ Disable MPS for this run Run ComfyUI using CPU instead: ```bash PYTORCH_ENABLE_MPS_FALLBACK=1 python main.py ``` or ```bash export PYTORCH_ENABLE_MPS_FALLBACK=1 python main.py ``` This lets unsupported operations fall back to CPU instead of crashing. --- ## 2️⃣ Reduce context length Your tensor dimension: ``` 2238 tokens ``` That is **very large for MPS attention**. Reduce max tokens in your node or prompt. Typical safe sizes: ``` 512 1024 ``` --- ## 3️⃣ Switch attention backend Some nodes let you change attention type. Instead of: ``` sdpa ``` try: ``` eager ``` or ``` flash_disabled ``` Apple Metal often breaks with SDPA. --- ## 4️⃣ Upgrade PyTorch Older MPS builds had this exact matmul bug. Upgrade: ```bash pip install --upgrade torch torchvision torchaudio ``` The bug was partially fixed after **PyTorch 2.2**. --- # Most likely root cause in your workflow From your logs earlier you are running: - **LTX video model (~15GB)** - **QwenVL** - **ComfyUI** - **Python 3.13** That combination is **very unstable on macOS**. --- # The stable stack for Macs If you want this to run smoothly, the best combo is: ``` Python 3.11 PyTorch 2.2 MPS fallback enabled bitsandbytes removed ``` --- # If you want, I can also show you something useful Since you're building **AI video pipelines**, I can give you a **ComfyUI workflow that runs 10x better on Macs**, using: - **entity["ai_model","Flux"]** for images - **entity["ai_model","Wan Video"]** for video - **entity["ai_model","Kokoro TTS"]** for voice This stack runs **way better on Apple Silicon** than the LTX/Qwen combo you're trying. And it’s the same stack people use for **AI content businesses**.

loc("mps_matmul"("(mpsFileLoc): /AppleInternal/Library/BuildRoots/4~CHS-ugA1l14pvN8Oy4lLaUF8xIef9jXHToA16Nw/Library/Caches/com.apple.xbs/Sources/MetalPerformanceShadersGraph/mpsgraph/MetalPerformanceShadersGraph/Core/Files/MPSGraphUtilities.mm":43:0)): error: incompatible dimensions loc("mps_matmul"("(mpsFileLoc): /AppleInternal/Library/BuildRoots/4~CHS-ugA1l14pvN8Oy4lLaUF8xIef9jXHToA16Nw/Library/Caches/com.apple.xbs/Sources/MetalPerformanceShadersGraph/mpsgraph/MetalPerformanceShadersGraph/Core/Files/MPSGraphUtilities.mm":43:0)): error: invalid shape LLVM ERROR: Failed to infer result type(s): "mps.matmul"(...) {} : (tensor<1x16x2238x128xf16>, tensor<1x8x128x2238xf16>) -> ( ??? ) zsh: abort PYTORCH_ENABLE_MPS_FALLBACK=1 python main.py

The crash is still coming from **entity["software","PyTorch"]** running on the **entity["software","Metal Performance Shaders"]** backend (Apple GPU). The key problem is the tensor shapes in the attention matmul: ``` tensor<1x16x2238x128xf16> tensor<1x8x128x2238xf16> ``` The **attention heads don’t match**: ``` 16 heads 8 heads ``` So the Metal kernel for `mps.matmul` cannot compute the result and aborts. Even though you enabled fallback: ```bash PYTORCH_ENABLE_MPS_FALLBACK=1 python main.py ``` this only helps for **unsupported operations**, not for **invalid tensor shapes**. So the crash still happens. --- ## The most common causes in this setup Given your previous logs with **entity["software","ComfyUI"]** and **entity["software","Qwen-VL"]**, one of these is happening: 1. **Token sequence too large** (2238 tokens in your tensor) 2. **Mismatched model + processor versions** 3. **Broken attention backend on MPS** 4. **Python 3.13 incompatibility** --- # Fixes that usually solve this ## 1️⃣ Reduce prompt / token length Your tensor dimension shows: ``` 2238 tokens ``` That is **extremely large for Apple MPS attention**. Try limiting the prompt or max tokens to: ``` 512 or 1024 ``` Many Qwen workflows break above ~1500 tokens on MPS. --- ## 2️⃣ Force CPU for the Qwen node Since this is happening inside the Qwen model, move that model off GPU. Before running: ```bash export PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0 export PYTORCH_ENABLE_MPS_FALLBACK=1 ``` Then start: ```bash python main.py --force-fp32 ``` This often pushes problematic layers to CPU. --- ## 3️⃣ Update PyTorch Some older builds had this exact Metal bug. Upgrade: ```bash pip install --upgrade torch torchvision torchaudio ``` Make sure you're at **PyTorch ≥ 2.2**. --- ## 4️⃣ Use Python 3.11 instead of 3.13 Your earlier log showed: ``` python3.13 ``` Most AI libraries (transformers, accelerate, etc.) are **not fully stable yet** on 3.13. Creating a new environment often fixes these strange shape errors. --- # If you want the honest diagnosis You're running a **very heavy multimodal stack on a Mac GPU**: - QwenVL - large video model (~15GB) - ComfyUI - Python 3.13 - MPS backend This combination frequently produces **Metal attention crashes** like the one you're seeing. --- ## The easiest practical workaround Run ComfyUI fully on CPU for the Qwen model: ```bash export PYTORCH_MPS_FALLBACK=1 export CUDA_VISIBLE_DEVICES="" python main.py ``` It will be slower but **stable**. --- 💡 If you'd like, I can also show you something useful for your setup: A **stable ComfyUI stack specifically optimized for Apple Silicon** that avoids these MPS crashes and runs **image + video + voice pipelines locally** without needing CUDA.

loc("mps_matmul"("(mpsFileLoc): /AppleInternal/Library/BuildRoots/4~CHS-ugA1l14pvN8Oy4lLaUF8xIef9jXHToA16Nw/Library/Caches/com.apple.xbs/Sources/MetalPerformanceShadersGraph/mpsgraph/MetalPerformanceShadersGraph/Core/Files/MPSGraphUtilities.mm":43:0)): error: incompatible dimensions loc("mps_matmul"("(mpsFileLoc): /AppleInternal/Library/BuildRoots/4~CHS-ugA1l14pvN8Oy4lLaUF8xIef9jXHToA16Nw/Library/Caches/com.apple.xbs/Sources/MetalPerformanceShadersGraph/mpsgraph/MetalPerformanceShadersGraph/Core/Files/MPSGraphUtilities.mm":43:0)): error: invalid shape LLVM ERROR: Failed to infer result type(s): "mps.matmul"(...) {} : (tensor<1x16x2238x128xf16>, tensor<1x8x128x2238xf16>) -> ( ??? ) zsh: abort python main.py --force-fp32

This error is coming from the **Apple GPU (Metal)** math kernel, not from your Python code. The key line is the tensor shapes: ``` tensor<1x16x2238x128xf16> tensor<1x8x128x2238xf16> ``` For a matrix multiply in transformer attention, the **head dimension must match**, but here it doesn’t: ``` 16 heads 8 heads ``` So the Metal kernel (`mps.matmul`) aborts. This is a **known issue when running large transformer models with the MPS backend in entity["software","PyTorch"] on Apple Silicon**. The crash happens inside **entity["software","Metal Performance Shaders"]**, which **cannot recover**, so Python exits. --- # What is actually causing it in your case Your earlier logs show you are running: - **entity["software","ComfyUI"]** - **entity["software","Qwen-VL"]** - a **~15GB video model** - **Python 3.13** The important clue in the tensor: ``` 2238 tokens ``` That means the **context length exploded**. MPS attention frequently breaks above **~1024 tokens**. --- # Fast fixes (most reliable) ## 1. Limit the token length In the node using **QwenVL**, reduce max tokens. Typical safe values: ``` 512 or 1024 ``` Your tensor shows **2238**, which is extremely high. --- ## 2. Disable SDPA attention Your logs earlier showed: ``` Attention backend selected: sdpa ``` SDPA is unstable on Apple GPUs. Force PyTorch to use math attention instead: ```bash export PYTORCH_ENABLE_MPS_FALLBACK=1 export PYTORCH_MPS_PREFER_METAL=0 python main.py ``` --- ## 3. Use CPU for the Qwen node Multimodal transformer layers often crash on MPS. You can force CPU by setting: ``` device = cpu ``` inside the node settings or environment: ```bash export PYTORCH_ENABLE_MPS_FALLBACK=1 export CUDA_VISIBLE_DEVICES="" python main.py ``` --- ## 4. Downgrade Python You are using **Python 3.13**, which is too new for most ML stacks. Stable combinations for ComfyUI are: ``` Python 3.10 Python 3.11 ``` 3.13 causes subtle tensor bugs with transformers. --- # The real practical answer Running **large multimodal models like Qwen-VL on Apple MPS** is currently unstable. Even when it runs, you will see: - tensor shape crashes - memory fragmentation - Metal kernel failures This is why most ComfyUI pipelines using Qwen run on **CUDA GPUs instead of Apple Silicon**. --- ✅ **The quickest thing to try right now:** ``` limit tokens to 512 disable sdpa run Qwen on CPU ``` That fixes about **80% of these crashes**. --- If you want, I can also show you something very useful: **How to run this entire ComfyUI pipeline reliably on a Mac** (image + video + voice models that actually work well on Apple Silicon).

loc("mps_matmul"("(mpsFileLoc): /AppleInternal/Library/BuildRoots/4~CHS-ugA1l14pvN8Oy4lLaUF8xIef9jXHToA16Nw/Library/Caches/com.apple.xbs/Sources/MetalPerformanceShadersGraph/mpsgraph/MetalPerformanceShadersGraph/Core/Files/MPSGraphUtilities.mm":43:0)): error: incompatible dimensions loc("mps_matmul"("(mpsFileLoc): /AppleInternal/Library/BuildRoots/4~CHS-ugA1l14pvN8Oy4lLaUF8xIef9jXHToA16Nw/Library/Caches/com.apple.xbs/Sources/MetalPerformanceShadersGraph/mpsgraph/MetalPerformanceShadersGraph/Core/Files/MPSGraphUtilities.mm":43:0)): error: invalid shape LLVM ERROR: Failed to infer result type(s): "mps.matmul"(...) {} : (tensor<1x16x2238x128xf16>, tensor<1x8x128x2238xf16>) -> ( ??? ) zsh: abort python main.py

This crash is happening inside the Apple GPU backend used by **entity["software","PyTorch"]**, which runs through **entity["software","Metal Performance Shaders"]** on Apple Silicon. The critical part of the error is the tensor shapes: ``` tensor<1x16x2238x128xf16> tensor<1x8x128x2238xf16> ``` For a matrix multiply used in transformer attention, the **attention head dimension must match**, but here it doesn’t: ``` 16 heads 8 heads ``` So the Metal kernel `mps.matmul` cannot compute the result and aborts the program. This is a **known failure mode when large transformer models run on MPS**, especially with vision-language models like **entity["software","Qwen-VL"]** inside **entity["software","ComfyUI"]**. --- # The biggest clue in your error Your tensor shows: ``` 2238 tokens ``` That means the model is trying to run attention over **2238 tokens**, which is very large for the Apple GPU backend. MPS often crashes somewhere above **~1000–1500 tokens**. --- # Most reliable fixes ## 1. Reduce token length Find the node feeding the Qwen model and lower the context or max tokens. Safe values: ``` 512 or 1024 ``` Anything near **2000+ tokens** frequently crashes on MPS. --- ## 2. Force fallback to CPU If the problematic layer runs on CPU instead of GPU, the crash usually disappears. Run: ```bash export PYTORCH_ENABLE_MPS_FALLBACK=1 python main.py ``` If that still crashes, force CPU execution: ```bash export CUDA_VISIBLE_DEVICES="" export PYTORCH_ENABLE_MPS_FALLBACK=1 python main.py ``` --- ## 3. Update PyTorch Older MPS kernels had attention bugs. Upgrade: ```bash pip install --upgrade torch torchvision torchaudio ``` You want **PyTorch ≥ 2.2**. --- ## 4. Use Python 3.11 Your earlier logs showed Python 3.13. Many ML libraries still behave unpredictably on it. Stable versions for **ComfyUI** are: ``` Python 3.10 Python 3.11 ``` --- # Practical diagnosis You're running a stack that is **very heavy for Apple GPU compute**: - ComfyUI - Qwen-VL multimodal model - a large video model (~15 GB) - MPS backend Even when configured correctly, this combination can trigger Metal kernel crashes. --- ✅ **The fastest thing to try right now** 1. Limit tokens to **512–1024** 2. Enable **MPS fallback** 3. Run the Qwen node on **CPU** That resolves most of these crashes. --- If you want, I can also show you **how to modify this workflow so it runs reliably on Macs** (there are a couple ComfyUI tricks that avoid these MPS tensor crashes entirely).