tsiendragon/qwen-image-finetune/qwen-image-edit-aipc-finetune-03-env-setup

conda create -n qwen-image-edit-xpu python=3.12 -y
conda activate qwen-image-edit-xpu

pip install torch torchvision --index-url https://download.pytorch.org/whl/xpu

pip install torch==2.11.0 torchvision --index-url https://download.pytorch.org/whl/xpu

# requirements.txt
- transformer_engine[pytorch]
+ # XPU: transformer_engine is CUDA-only — comment out
+ # transformer_engine[pytorch]

- bitsandbytes
+ bitsandbytes>=0.48.2

pip install -r requirements.txt

set "NoDefaultCurrentDirectoryInExePath="
call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat" --force
set "NoDefaultCurrentDirectoryInExePath=1"

# probe_hw.py
# Probe the local Intel AI PC hardware + key software components. Emits a JSON dict to stdout.
# Consumed by recommend_config.py (Step 4). Network policy: does NOT touch the network.
#
# Output schema (keep field names + types stable):
#   xpu_model         str | null   the XPU device name string, or null if no XPU
#   xpu_available     bool         torch.xpu.is_available()
#   vram_gb           float        GiB (total_memory / 2**30); matches Task Manager GPU figure
#   ram_gb            float        GiB (virtual_memory().total / 2**30); matches Task Manager Memory
#   ram_available_gb  float        GiB (virtual_memory().available / 2**30)
#   oneapi_version    str | null   probed from `icpx --version`, null if not on PATH
#   conda_env         str | null   CONDA_DEFAULT_ENV, null if not in conda
#   bnb_version       str | null   bitsandbytes.__version__, null if not installed
#   bnb_xpu_available bool         bnb has XPU backend module
#   torch_version     str | null
#   platform          str          "windows" / "linux" / "darwin"
#   level_zero_sdk    str | null   LEVEL_ZERO_V1_SDK_PATH or ZE_PATH if set, else null
#
# Usage: python probe_hw.py > probe.json
import argparse, json, os, platform, re, subprocess
def _probe_xpu():
    info = {"xpu_model": None, "xpu_available": False, "vram_gb": 0.0, "torch_version": None}
    try:
        import torch
        info["torch_version"] = torch.__version__
        if hasattr(torch, "xpu") and torch.xpu.is_available():
            info["xpu_available"] = True
            props = torch.xpu.get_device_properties(0)
            info["xpu_model"] = props.name
            # GiB (binary) so the figure matches what Windows Task Manager shows.
            info["vram_gb"] = round(props.total_memory / 2**30, 2)
    except ImportError:
        pass
    return info
def _probe_ram():
    try:
        import psutil
        vm = psutil.virtual_memory()
        return {"ram_gb": round(vm.total / 2**30, 2), "ram_available_gb": round(vm.available / 2**30, 2)}
    except ImportError:
        try:
            ram = os.sysconf("SC_PHYS_PAGES") * os.sysconf("SC_PAGE_SIZE")
            return {"ram_gb": round(ram / 2**30, 2), "ram_available_gb": -1.0}
        except (ValueError, AttributeError):
            return {"ram_gb": -1.0, "ram_available_gb": -1.0}
def _probe_oneapi():
    # Return the Intel oneAPI toolkit version (e.g. '2025.3'). Parse the InstalledDir path from
    # `icpx --version` (two-part toolkit version), falling back to the Compiler line. Requires
    # setvars.bat to have been called (Windows) or oneAPI on PATH. Returns None if icpx not found.
    try:
        which = "where" if platform.system() == "Windows" else "which"
        r = subprocess.run([which, "icpx"], capture_output=True, text=True, timeout=5)
        if r.returncode != 0:
            return None
        r2 = subprocess.run(["icpx", "--version"], capture_output=True, text=True, timeout=10)
        if r2.returncode != 0:
            return None
        output = r2.stdout + r2.stderr
        m = re.search(r"[Ii]nstalled[Dd]ir.*[/\\]compiler[/\\](\d+\.\d+)[/\\]", output)
        if m:
            return m.group(1)
        m = re.search(r"Compiler (\d+\.\d+)", output)
        return m.group(1) if m else None
    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
        return None
def _probe_level_zero():
    # Triton XPU requires Level Zero headers to JIT-compile kernels. Normally provided by the GPU
    # driver via LEVEL_ZERO_V1_SDK_PATH; ZE_PATH is the manual fallback. null here means Triton
    # kernel compilation will likely fail — see Step 6 troubleshooting.
    for var in ("LEVEL_ZERO_V1_SDK_PATH", "ZE_PATH"):
        val = os.environ.get(var)
        if val:
            return val
    return None
def _probe_bnb():
    info = {"bnb_version": None, "bnb_xpu_available": False}
    try:
        import bitsandbytes as bnb
        info["bnb_version"] = bnb.__version__
        try:
            import bitsandbytes.backends.xpu  # noqa: F401
            info["bnb_xpu_available"] = True
        except ImportError:
            pass
    except ImportError:
        pass
    return info
def main():
    argparse.ArgumentParser(description="Probe Intel AI PC hardware + key software components.").parse_args()
    result = {
        **_probe_xpu(),
        **_probe_ram(),
        "oneapi_version": _probe_oneapi(),
        "conda_env": os.environ.get("CONDA_DEFAULT_ENV"),
        **_probe_bnb(),
        "platform": platform.system().lower(),
        "level_zero_sdk": _probe_level_zero(),
    }
    print(json.dumps(result, indent=2))
if __name__ == "__main__":
    main()

python probe_hw.py

pip install "bitsandbytes>=0.48.2"

pip install torch torchvision --index-url https://download.pytorch.org/whl/xpu --force-reinstall

pip uninstall triton pytorch-triton pytorch-triton-xpu triton-xpu triton-windows -y
REM Then install the correct package, e.g. for torch 2.11.0+xpu:
pip install triton-xpu==3.7.*