[Bug]: Intel Arc GPU (XPU) not detected with PyTorch builds integrating XPU support (e.g., 2.7.1+XPU)

[DrThodt2021]

Checklist

• The issue exists after disabling all extensions
• The issue exists on a clean installation of webui
• The issue is caused by an extension, but I believe it is caused by a bug in the webui
• The issue exists in the current version of the webui
• The issue has not been reported before recently
• The issue has been reported before but has not been fixed yet

What happened?

When attempting to run Stable Diffusion WebUI (Automatic1111) on a Linux system equipped with an Intel Arc A770 GPU and a PyTorch version that natively integrates XPU (Intel GPU) support (such as PyTorch 2.7.1+XPU), the WebUI consistently fails to detect and utilize the Intel Arc GPU. Instead, it defaults to performing image generation on the CPU, even when the --use-ipex command-line argument is explicitly provided in webui-user.sh.

Steps to reproduce the problem

1. System Setup: Configure a Linux system with an Intel Arc A770 GPU.
2. Driver Installation: Ensure the latest Intel GPU drivers for Linux are installed and correctly loaded (e.g., i915 kernel module, level-zero, firmware, etc.).
3. PyTorch Installation: Install a PyTorch build with integrated XPU support (e.g., PyTorch 2.7.1+XPU). A relevant community guide for this setup can be found here.

• Verification: Confirm that PyTorch correctly recognizes the XPU by executing python -c "import torch; print(torch.xpu.is_available());" within your PyTorch environment. This command should return True.

4. Stable Diffusion WebUI Setup: Clone and set up the Automatic1111 Stable Diffusion WebUI.
5. Configure WebUI Launch: In your webui-user.sh file, ensure COMMANDLINE_ARGS includes --use-ipex. Example: export COMMANDLINE_ARGS="--use-ipex --precision full --no-half ".
6. Launch WebUI: Start Stable Diffusion WebUI using ./webui.sh.
7. Observe Behavior: Initiate an image generation task. The WebUI will incorrectly utilize the CPU instead of the Intel Arc GPU (XPU).

What should have happened?

When the --use-ipex command-line argument is provided and a PyTorch build with native XPU support (like PyTorch 2.7.1+XPU) is correctly installed and torch.xpu.is_available() returns True, Stable Diffusion WebUI should correctly detect and automatically utilize the Intel Arc GPU (XPU) for accelerated image generation.

What browsers do you use to access the UI ?

Other

Sysinfo

not applicable but anyway

sysinfo-2025-06-28-05-33.json

Console logs

not applicable

Additional information

• GPU Model: Intel Arc A770
• Operating System: Linux (tested on PikaOS; issue likely affects other Linux distributions as well)
• PyTorch Version: 2.7.1+XPU (XPU support is integrated into the core PyTorch package, making a separate intel_extension_for_pytorch module unnecessary for functionality).

Root Cause Analysis:

• The problem lies in the XPU device detection logic within the Stable Diffusion WebUI, specifically in files like modules/xpu_specific.py.
• The relevant code snippet for XPU detection (has_ipex variable, which translates to xpu_specific.has_xpu in modules/devices.py) relies on a try...except block attempting to import intel_extension_for_pytorch.
• Since PyTorch 2.7.1+XPU integrates the functionality of intel_extension_for_pytorch directly, the standalone intel_extension_for_pytorch module is often not installed separately (and is not needed for torch.xpu.is_available() to be true).
• Consequently, the import intel_extension_for_pytorch call fails within xpu_specific.py, causing the detection flag (has_ipex / xpu_specific.has_xpu) to remain False.
• This leads modules/devices.py's get_optimal_device_name() function to incorrectly fall back to the CPU, despite the GPU being fully functional and available via torch.xpu.

Temporary Workaround (User's Solution):
A temporary workaround that resolves the issue is to directly force the XPU backend by manually changing the last line within the def get_optimal_device_name(): function in modules/devices.py from return "cpu" to return "xpu". This bypasses the flawed detection logic, and the WebUI then successfully uses the Intel Arc GPU.

Proposed Clean Solution (for xpu_specific.py):
To provide a more robust and future-proof detection mechanism, the XPU availability check in xpu_specific.py should be modified to directly query torch.xpu.is_available(). This would eliminate the dependency on the presence of the separate intel_extension_for_pytorch module for detection.
Example modification within xpu_specific.py:

import torch
# ... other necessary imports ...

has_xpu_device_natively_available = False
try:
    if hasattr(torch, 'xpu') and torch.xpu.is_available():
        has_xpu_device_natively_available = True
except Exception:
    # Log error if needed, but ensure has_xpu_device_natively_available remains False
    pass

# This variable should be the one accessed by modules/devices.py
# If it was originally named 'has_ipex', retain that name for compatibility.
has_ipex = has_xpu_device_natively_available

# Ensure get_xpu_device_string() also uses torch.xpu methods directly if present.

[RogerWeihrauch]

Hi all
pls see also here:
#14461
may be I found a workaround on this, but is in testing actually.
.. see my comment @EnD.

Regards,
Roger

[RogerWeihrauch]

or also in webui-user.sh for simpler method, to be tested:
try that:

install command for torch

#export TORCH_COMMAND="pip install torch==1.12.1+cu113 --extra-index-url https://download.pytorch.org/whl/cu113"
.. and set u'r appropriate version here for INTEL?
Regards,
Roger

[DrThodt2021]

I believe my issue in #17047 is slightly different. PyTorch itself correctly detects the XPU (as torch.xpu.is_available() returns True). The core problem is that the Stable Diffusion WebUI application fails to detect the XPU and falls back to CPU. This happens because it still attempts to import intel_extension_for_pytorch, which is no longer separately necessary with newer PyTorch versions (like 2.7.1+XPU) that integrate this functionality directly.

My proposed solution aims to update the detection logic in modules/xpu_specific.py to directly query torch.xpu.is_available(), removing the dependency on the separate extension module.

Hope this clarifies the distinction. Thanks!

[RogerWeihrauch]

@DrThodt2021
Well, ok, sorry for this misunderstanding.
So, just to get u right, since I still always have to fiddle around with the correct packages on Torch and Pytorch4ARC GPU:
Is it right that u say that latest packages from python on torch will suffice?
And that those packages from Intel's repos are still no longer necessary?
Thanks for clearing up to me.
Regards,
Roger

[DrThodt2021]

I don't know if 2.7.1+XPU is the latest package; I just followed this guide for installation. After that, it should technically work, but it doesn't, because of how Automatic1111 tries to recognize the XPU capability of the hardware.

As described, Automatic checks if --use-ipex is set AND if intel_extension_for_pytorch is installed. With PyTorch 2.7.1+XPU already installed and working, the additional Intel_extension_for_pytorch module is not needed, which causes this check to fail. Consequently, Automatic1111 uses the CPU instead of the GPU.

I forced Automatic1111 to use the GPU by changing a default value in modules/devices.py. While this workaround functions in my setup, it's not a safe or proper long-term solution. That's why I provided a concept for a better mechanism to recognize the XPU capability.

[RogerWeihrauch]

@DrThodt2021:
Hmm, u'r right; I just now ran in to the same issue like u did, BUT trying to setup SDNext with '--use-ipex'. Also installed my own venv, not via using webui.sh, than:
'pip install torch==2.7.1+xpu torchvision==0.22.1+xpu torchaudio==2.7.1+xpu intel-cmplr-lib-rt intel-cmplr-lib-ur intel-cmplr-lic-rt intel-sycl-rt ' like in u'r link,
and when starting/running/first booting with 'python launch.py --debug --use-ipex' I get:
RuntimeError: No XPU devices are available.
So, I will try to also noe additionally to install Intel's extensions for pytorch an report back.
Regards,
Roger

[RogerWeihrauch]

BTW: may u tell me which entry u added in modules/devices.py?
Roger

[DrThodt2021]

Sure. Search for def get_optimal_device_name(): (approx. at line 50):

 if torch.cuda.is_available():
        return get_cuda_device_string()

    if has_mps():
        return "mps"

    if has_xpu():
        return xpu_specific.get_xpu_device_string()

    if npu_specific.has_npu:
        return npu_specific.get_npu_device_string()

    return "cpu"

The last line return "cpu" determine the "default" state, which ist used if the above checks (cuda, mps, xpu, npu) fails. I just changed this to return "xpu". This forces Automatic1111 to use xpu as default (even if the check before failed) and will probably fail if you don't have a propper set up XPU device. So this may work, but it's not recommended, exept you're absolutly sure you have a propper set up XPU GPU.

[desmondsow]

You may try SD.Next which is currently maintained and support OpenVINO and IPEX im my opinion.

[DrThodt2021]

I would agree, if you can explan me how to overcome the 75 token limit in SD.Next