👋 Hello @hzdzkjdxyjs, thank you for submitting a ultralytics/ultralytics 🚀 PR! This is an automated review assistant, and a Ultralytics engineer will be by shortly to help further. To ensure a seamless integration of your work, please review the following checklist:

• ✅ Define a Purpose: Clearly explain the purpose of your Intel XPU support and related changes in your PR description, and link to any relevant issues. Ensure your commit messages are clear, concise, and adhere to the project's conventions.
• ✅ Synchronize with Source: Confirm your PR is synchronized with the ultralytics/ultralytics main branch. If it's behind, update it by clicking the Update branch button or by running git pull and git merge main locally.
• ✅ Ensure CI Checks Pass: Verify all Ultralytics Continuous Integration (CI) checks are passing. If any checks fail (including new XPU tests), please address the issues.
• ✅ Update Documentation: Update the relevant documentation for any new or modified features, especially around Intel XPU support and device selection (e.g., device=xpu usage).
• ✅ Add Tests: If applicable, include or update tests to cover your changes, and confirm that all tests are passing locally and in CI. You’ve added an XPU test already—please ensure it behaves correctly in environments without XPU (e.g., via skips).
• ✅ Sign the CLA: Please ensure you have signed our Contributor License Agreement if this is your first Ultralytics PR by writing I have read the CLA Document and I sign the CLA in a new message.
• ✅ Minimize Changes: Limit your changes to the minimum necessary for your feature addition. "It is not daily increase but daily decrease, hack away the unessential. The closer to the source, the less wastage there is." — Bruce Lee

For more guidance, please refer to our Contributing Guide. Don't hesitate to leave a comment if you have any questions. Thank you for contributing to Ultralytics! 🚀

关于cuda和xpu冲突问题，我认为这个问题不会有影响，因为在一个环境中你无法同时安装cuda或者xpu的torch，所以对于他们的代码设计来说，不需要考虑冲突问题

Thanks for the very detailed PR and extra note on the CUDA/XPU interaction.

You’re right that with the current Intel wheels you typically don’t get CUDA and XPU in the same environment, but for long‑term robustness it would still be better if the XPU paths only triggered when the selected device is actually XPU, rather than just when torch.xpu.is_available(). For example, in _get_memory and _clear_memory we can key off self.device.type so a hypothetical future build with both backends can’t accidentally route CUDA runs through XPU helpers:

def _get_memory(self, fraction=False):
    memory, total = 0, 0
    if self.device.type == "mps":
        ...
    elif self.device.type == "xpu":
        memory = torch.xpu.memory_allocated(self.device)
        total = torch.xpu.get_device_properties(self.device).total_memory
        return (memory / total if total > 0 else 0) if fraction else (memory / 2**30)
    elif self.device.type != "cpu":
        memory = torch.cuda.memory_reserved()
        if fraction:
            total = torch.cuda.get_device_properties(self.device).total_memory
    return (memory / total if total > 0 else 0) if fraction else (memory / 2**30)

and similarly in _clear_memory only call torch.xpu.empty_cache() when self.device.type == "xpu". In select_device, keeping XPU mapping behind explicit device strings like xpu / xpu:0 and leaving bare numeric strings ("0", "0,1", etc.) for CUDA will also avoid surprises if a mixed backend ever appears.

If you can update those pieces along these lines, the rest of the changes look like a good, minimal first step for single‑XPU support and we can continue the detailed review in this PR.

Codecov Report

❌ Patch coverage is 25.80645% with 23 lines in your changes missing coverage. Please review.

📢 Thoughts on this report? Let us know!

为了能够更好的支持您所说的情况我做了以下修改来使框架鲁棒性更强

1.Added standalone support for XPU device information queries, separating it from get_gpu_info, and extended system information reporting to include XPU details

• Added XPU device information retrieval in ultralytics/ultralytics/utils/checks.py collect_system_info()
• Added a new get_xpu_info ultralytics/ultralytics/utils/checks.py collect_system_info():

@functools.lru_cache
def get_xpu_info(index):
    """Return a string with system GPU information, i.e. 'Tesla T4, 15102MiB'."""
    if hasattr(torch, "xpu") and torch.xpu.is_available():
        properties = torch.xpu.get_device_properties(index)
        return f"{properties.name}, {properties.total_memory / (1 << 20):.0f}MiB"

def collect_system_info():
    """Collect and print relevant system information including OS, Python, RAM, CPU, and CUDA.

    Returns:
        (dict): Dictionary containing system information.
    """
    import psutil  # scoped as slow import

    from ultralytics.utils import ENVIRONMENT  # scope to avoid circular import
    from ultralytics.utils.torch_utils import get_cpu_info, get_gpu_info, get_xpu_info

    gib = 1 << 30  # bytes per GiB
    cuda = torch.cuda.is_available()
    xpu = hasattr(torch, "xpu") and torch.xpu.is_available() 
    check_yolo()
    total, _used, free = shutil.disk_usage("/")

    info_dict = {
        "OS": platform.platform(),
        "Environment": ENVIRONMENT,
        "Python": PYTHON_VERSION,
        "Install": "git" if GIT.is_repo else "pip" if IS_PIP_PACKAGE else "other",
        "Path": str(ROOT),
        "RAM": f"{psutil.virtual_memory().total / gib:.2f} GB",
        "Disk": f"{(total - free) / gib:.1f}/{total / gib:.1f} GB",
        "CPU": get_cpu_info(),
        "CPU count": os.cpu_count(),
        "GPU": get_gpu_info(index=0) if cuda else None,
        "XPU": get_xpu_info() if xpu else None,
        "GPU count": torch.cuda.device_count() if cuda else None,
        "XPU count": torch.xpu.device_count() if xpu else None,
        "CUDA": torch.version.cuda if cuda else None,
    }

• to verify that this API is present and operational

(base) root@b60:~# conda activate B60
(B60) root@b60:~# python
Python 3.10.19 (main, Oct 21 2025, 16:43:05) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>> torch.xpu.device_count()
2

2.Ensure that only explicit xpu device strings (e.g., xpu, xpu:0) enter this branch, preventing numeric CUDA-style indices such as "0" or "1" from being interpreted as XPU devices. The XPU device mapping is preserved strictly as xpu:index.

• To verify that the model is correctly running on the XPU device,(e.g., xpu,:1) I used:

watch -n 0.5 xpu-smi stats -d 1 -j

• Training is running on xpu:1.

    elif device.startswith("xpu"):  # Intel XPU
        parts = device.split(":")
        index = int(parts[1]) if len(parts) > 1 else 0
        if verbose:
            info = get_xpu_info(index)
            s += f"XPU:{index} ({info})\n"
            LOGGER.info(s if newline else s.rstrip())
        return torch.device("xpu", index)

3.device-type checks are used when performing memory queries and related operations

• /ultralytics/ultralytics/engine/trainer.py _get_memory()/_clear_memory()

    def _get_memory(self, fraction=False):
        """Get accelerator memory utilization in GB or as a fraction of total memory."""
        memory, total = 0, 0
        if self.device.type == "mps":
            memory = torch.mps.driver_allocated_memory()
            if fraction:
                return __import__("psutil").virtual_memory().percent / 100
        elif self.device.type != "cpu" and self.device.type == "xpu":
            memory = torch.xpu.memory_allocated(self.device)
            total = torch.xpu.get_device_properties(self.device).total_memory
            return ((memory / total) if total > 0 else 0) if fraction else (memory / 2**30)
        elif self.device.type != "cpu":
            memory = torch.cuda.memory_reserved()
            if fraction:
                total = torch.cuda.get_device_properties(self.device).total_memory
        return ((memory / total) if total > 0 else 0) if fraction else (memory / 2**30)
    def _clear_memory(self, threshold: float | None = None):
        """Clear accelerator memory by calling garbage collector and emptying cache."""
        if threshold:
            assert 0 <= threshold <= 1, "Threshold must be between 0 and 1."
            if self._get_memory(fraction=True) <= threshold:
                return
        gc.collect()
        if self.device.type == "mps":
            torch.mps.empty_cache()
        elif self.device.type == "cpu":
            return
        elif self.device.type == "xpu":
            torch.xpu.empty_cache()
        else:
            torch.cuda.empty_cache()

4.renamed to test_xpu to comply with the test script naming conventions

• ultralytics/tests/test_xpu.py

5.Lastly, I added an example in the Markdown file demonstrating how to train a model. You may update it on the website to make it easier for users to follow.

• Specifying device=xpu will automatically run on xpu:0.

yolo train model=yolo11n.pt data=coco128.yaml epochs=50 imgsz=256 device=xpu

• If you want to run on a different device, you can explicitly specify:

device=xpu:1
device=xpu:2

如果想要进一步支持多卡训练，intel的工程师是这样和我说的，以下这几个函数是支持多卡的最重要的函数

• vllm/vllm/platforms/init.py xpu_platform_plugin()

• vllm/vllm/utils/torch_utils.py

def xpu_platform_plugin() -> str | None:
    is_xpu = False
    logger.debug("Checking if XPU platform is available.")
    try:
        # installed IPEX if the machine has XPUs.
        import intel_extension_for_pytorch  # noqa: F401
        import torch

        if supports_xccl():
            dist_backend = "xccl"
        else:
            dist_backend = "ccl"
            import oneccl_bindings_for_pytorch  # noqa: F401

        if hasattr(torch, "xpu") and torch.xpu.is_available():
            is_xpu = True
            from vllm.platforms.xpu import XPUPlatform

            XPUPlatform.dist_backend = dist_backend
            logger.debug("Confirmed %s backend is available.", XPUPlatform.dist_backend)
            logger.debug("Confirmed XPU platform is available.")
    except Exception as e:
        logger.debug("XPU platform is not available because: %s", str(e))

    return "vllm.platforms.xpu.XPUPlatform" if is_xpu else None

def supports_xccl() -> bool:
    return (
        is_torch_equal_or_newer("2.8.0.dev") and torch.distributed.is_xccl_available()
    )

• 他的xccl和ccl两个dist
• 要导入对应的包才能支持注册，因为native不在包中
• 其他具体的我也在研究，我目前能跑通多卡的案例就是这个，intel的团队暂时也没有对应的训练支持，也许我们走在了他们前面
• 现在我能够提供的信息就是那么多
• 当然还有一点比较重要intel有一个参数可以控制oneAPI来底层控制显卡，但不能控制torch
• ZE_AFFINITY_MASK= index，index1···
• https://github.com/hzdzkjdxyjs/How-to-use-llamafactory-at-B60Pro/blob/main/Muliti_GPU_Train.md

现在我的想法是我想研究一下为什么llamafactory可以支持多卡训练，可能这是关键，但是llamafactory似乎本身不支持多卡训练，支持多卡训练的是背后的pip包比如transformer

Nice follow‑up, the XPU‑specific helpers and stricter device handling make the design more robust, and the renamed test_xpu looks good for targeted coverage.

A couple of small tweaks will help clean things up before we go deeper into review:

1. It would be better to keep get_xpu_info alongside get_gpu_info in ultralytics/utils/torch_utils.py and import it into collect_system_info(), and to give it a default index so your call in collect_system_info works without arguments, for example:

@functools.lru_cache
def get_xpu_info(index: int = 0):
    """Return a string with system XPU information, i.e. 'Intel(R) Graphics..., 15102MiB'."""
    if hasattr(torch, "xpu") and torch.xpu.is_available():
        props = torch.xpu.get_device_properties(index)
        return f"{props.name}, {props.total_memory / (1 << 20):.0f}MiB"
    return None

and in collect_system_info() something like:

"XPU": get_xpu_info(0) if xpu else None,
"XPU count": torch.xpu.device_count() if xpu else None,

2. In _get_memory, the condition elif self.device.type != "cpu" and self.device.type == "xpu": can just be elif self.device.type == "xpu": to avoid redundant checks and keep the flow clearly mps → xpu → cuda.

The multi‑XPU notes and the xpu_platform_plugin / xccl hints are very helpful context, but as you said they imply a larger refactor (backend abstraction, DDP launch, optional IPEX/oneCCL integration), so it would be best to keep this PR strictly single‑XPU and minimal, and treat multi‑XPU as a follow‑up design/PR once this path is stable.

The CLI device=xpu example is also useful; once XPU support is merged we can look at adding a short Intel XPU section to the training docs on Ultralytics documentation so users can discover it easily.

非常感谢您耐心的指导，确实这样写代码逻辑会更严谨，我按照您的要求已经做了修改，希望有机会能和您的团队一起尝试进行多卡训练的修改，我也会继续探索相关的研究。

First, I want to express my sincere gratitude — thank you for patiently guiding me through the revisions.
Also, this is my very first PR, so I’d like to ask: approximately how long does it usually take for a PR to be reviewed and merged?
I’m really happy to contribute to this open-source project and excited to see my work being helpful.

考虑到本xpu是单卡训练，那么会有两种情况，第一种情况是使用多卡训练，在本函数中，我添加了多卡识别，通过字符“，”识别，第二个是超过xpu的索引告警，此告警由torch执行

• /ultralytics/ultralytics/utils/torch_utils.py select_device()

    elif device.startswith("xpu"):  # Intel XPU
        index_str = device.split(":", 1)[1] if ":" in device else "0"
        if "," in index_str:
            msg = f"Invalid XPU 'device={device}' requested. Use a single index 0-15."
            LOGGER.warning(msg)
            raise ValueError(msg)
        index = int(index_str)
        if verbose:
            info = get_xpu_info(index)
            s += f"XPU:{index} ({info})\n"
            LOGGER.info(s if newline else s.rstrip())
        return torch.device("xpu", index)

• 原来的函数如果使用多卡训练时的情况

(B60) root@b60:~/ultralytics# yolo train model=yolo11n.pt data=coco128.yaml epochs=3 imgsz=256 device=xpu:0,1
Traceback (most recent call last):
  File "/root/anaconda3/envs/B60/bin/yolo", line 7, in <module>
    sys.exit(entrypoint())
  File "/root/ultralytics/ultralytics/cfg/__init__.py", line 985, in entrypoint
    getattr(model, mode)(**overrides)  # default args from model
  File "/root/ultralytics/ultralytics/engine/model.py", line 768, in train
    self.trainer = (trainer or self._smart_load("trainer"))(overrides=args, _callbacks=self.callbacks)
  File "/root/ultralytics/ultralytics/models/yolo/detect/train.py", line 63, in __init__
    super().__init__(cfg, overrides, _callbacks)
  File "/root/ultralytics/ultralytics/engine/trainer.py", line 126, in __init__
    self.device = select_device(self.args.device)
  File "/root/ultralytics/ultralytics/utils/torch_utils.py", line 198, in select_device
    index = int(index_str)
ValueError: invalid literal for int() with base 10: '0,1'

• 现在的函数超过单卡会由本函数报警

(B60) root@b60:~/ultralytics# yolo train model=yolo11n.pt data=coco128.yaml epochs=3 imgsz=256 device=xpu:0,1
WARNING ⚠️ Invalid XPU 'device=xpu:0,1' requested. Only a single XPU device is supported.
Traceback (most recent call last):
  File "/root/anaconda3/envs/B60/bin/yolo", line 7, in <module>
    sys.exit(entrypoint())
  File "/root/ultralytics/ultralytics/cfg/__init__.py", line 985, in entrypoint
    getattr(model, mode)(**overrides)  # default args from model
  File "/root/ultralytics/ultralytics/engine/model.py", line 768, in train
    self.trainer = (trainer or self._smart_load("trainer"))(overrides=args, _callbacks=self.callbacks)
  File "/root/ultralytics/ultralytics/models/yolo/detect/train.py", line 63, in __init__
    super().__init__(cfg, overrides, _callbacks)
  File "/root/ultralytics/ultralytics/engine/trainer.py", line 126, in __init__
    self.device = select_device(self.args.device)
  File "/root/ultralytics/ultralytics/utils/torch_utils.py", line 198, in select_device
    raise ValueError(msg)
ValueError: Invalid XPU 'device=xpu:0,1' requested. Only a single XPU device is supported.

• intel最新的蓝戟B60Pro双芯显卡最多在一台服务器上能插16张，对于非整数和超过限制的情况均会报警
• 超过最大index会由torch报警

(B60) root@b60:~/ultralytics# yolo train model=yolo11n.pt data=coco128.yaml epochs=3 imgsz=256 device=xpu:16
Traceback (most recent call last):
  File "/root/anaconda3/envs/B60/bin/yolo", line 7, in <module>
    sys.exit(entrypoint())
  File "/root/ultralytics/ultralytics/cfg/__init__.py", line 985, in entrypoint
    getattr(model, mode)(**overrides)  # default args from model
  File "/root/ultralytics/ultralytics/engine/model.py", line 768, in train
    self.trainer = (trainer or self._smart_load("trainer"))(overrides=args, _callbacks=self.callbacks)
  File "/root/ultralytics/ultralytics/models/yolo/detect/train.py", line 63, in __init__
    super().__init__(cfg, overrides, _callbacks)
  File "/root/ultralytics/ultralytics/engine/trainer.py", line 126, in __init__
    self.device = select_device(self.args.device)
  File "/root/ultralytics/ultralytics/utils/torch_utils.py", line 206, in select_device
    info = get_xpu_info(index)
  File "/root/ultralytics/ultralytics/utils/torch_utils.py", line 137, in get_xpu_info
    properties = torch.xpu.get_device_properties(index)
  File "/root/anaconda3/envs/B60/lib/python3.10/site-packages/torch/xpu/__init__.py", line 262, in get_device_properties
    return _get_device_properties(device)  # type: ignore[name-defined]  # noqa: F821
RuntimeError: The device index is out of range. It must be in [0, 2), but got 16.

Thanks again for all the careful updates—your latest changes around select_device (explicitly rejecting device=xpu:0,1 and keeping XPU strictly single‑device) plus the XPU‑specific helpers are well aligned with the scope we discussed and will make misconfigurations much clearer for users.

On review/merge timing, we can’t promise a specific timeframe, but this PR is now in a good shape for further maintainer review and we’ll continue any follow‑up discussion here. For multi‑XPU, treating it as a separate design/PR once this single‑XPU path is stable is exactly the right direction, and the notes you’ve gathered about Intel’s backend (xccl/ccl, affinity masks, etc.) will be very useful when we explore that; thanks for helping push the YOLO ecosystem onto more hardware for the whole community.

boss 我更新了 新的多xpu 训练框架 目前已经完成#22850

Nice, thanks for splitting multi‑XPU into a separate PR—keeping #22836 focused on single‑XPU support and handling multi‑XPU in #22850 is exactly what we need; we’ll continue any multi‑XPU discussion and review on that new PR.