torchruntime 1.0.2__py3-none-any.whl

torchruntime/__init__.py

@@ -0,0 +1,2 @@
+from .installer import install
+from .configure import init_torch

torchruntime/__main__.py

@@ -0,0 +1,52 @@
+from .installer import install
+
+
+def print_usage():
+    """Print usage information with examples."""
+    usage = """
+Usage: python -m torchruntime <command> [arguments]
+
+Commands:
+    install             Install PyTorch packages
+    --help             Show this help message
+
+Examples:
+    python -m torchruntime install
+    python -m torchruntime install torch==2.2.0 torchvision==0.17.0
+    python -m torchruntime install torch>=2.0.0 torchaudio
+    python -m torchruntime install torch==2.1.* torchvision>=0.16.0 torchaudio==2.1.0
+
+If no packages are specified, the latest available versions
+of torch, torchaudio and torchvision will be installed.
+
+Version specification formats (follows pip format):
+    package==2.1.0     Exact version
+    package>=2.0.0     Minimum version
+    package<=2.2.0     Maximum version
+    package~=2.1.0     Compatible release
+    package==2.1.*     Any 2.1.x version
+    package            Latest version
+    """
+    print(usage.strip())
+
+
+def main():
+    import sys
+
+    if len(sys.argv) < 2 or sys.argv[1] in ["--help", "-h"]:
+        print_usage()
+        return
+
+    command = sys.argv[1]
+
+    if command == "install":
+        # Pass all arguments after 'install' to the install function
+        package_versions = sys.argv[2:] if len(sys.argv) > 2 else None
+        install(package_versions)
+    else:
+        print(f"Unknown command: {command}")
+        print_usage()
+
+
+if __name__ == "__main__":
+    main()

torchruntime/configure.py

@@ -0,0 +1,80 @@
+import os
+
+from .device_db import get_discrete_gpus
+from .platform_detection import get_torch_platform, os_name
+
+
+def init_torch():
+    discrete_gpu_infos = get_discrete_gpus()
+    torch_platform = get_torch_platform(discrete_gpu_infos)
+
+    if torch_platform.startswith("rocm"):
+        check_rocm_permissions()
+        set_rocm_env_vars(discrete_gpu_infos, torch_platform)
+    elif os_name == "Darwin":
+        _set_env_vars({"PYTORCH_ENABLE_MPS_FALLBACK": "1"})
+
+
+def check_rocm_permissions():
+    if not os.access("/dev/kfd", os.W_OK):
+        print(
+            """#########################################################################
+            #                    No write access to /dev/kfd !                      #
+            #########################################################################
+
+            Without this, the ROCm driver will probably not be able to initialize the GPU and torch will use the CPU for rendering.
+
+            Follow the instructions on this site to configure access to /dev/kfd:
+            https://github.com/easydiffusion/easydiffusion/wiki/AMD-on-Linux#access-permissions"""
+        )
+
+
+def set_rocm_env_vars(discrete_gpu_infos, torch_platform):
+    device_names = [device_name for *_, device_name in discrete_gpu_infos]
+
+    env = {}
+
+    # interesting reading:
+    # gfx config from: https://web.archive.org/web/20241228163540/https://llvm.org/docs/AMDGPUUsage.html#processors
+    # more info: https://web.archive.org/web/20241209013717/https://discuss.linuxcontainers.org/t/rocm-and-pytorch-on-amd-apu-or-gpu-ai/19743
+    # this thread is great for understanding the status of torch support for RDNA 1 (i.e. 5000 series): https://github.com/ROCm/ROCm/issues/2527
+    # past settings from: https://github.com/easydiffusion/easydiffusion/blob/20d77a85a1ed766ece0cc4b6a55dca003bce262c/scripts/check_modules.py#L405-L420
+
+    if any(device_name.startswith("Navi 3") for device_name in device_names):
+        print("[INFO] Applying Navi 3x settings")
+        env["HSA_OVERRIDE_GFX_VERSION"] = "11.0.0"
+    elif any(device_name.startswith("Navi 2") for device_name in device_names):
+        print("[INFO] Applying Navi 2x settings")
+        env["HSA_OVERRIDE_GFX_VERSION"] = "10.3.0"
+    elif any(device_name.startswith("Navi 1") for device_name in device_names):
+        print("[INFO] Applying Navi 1x settings")
+        env["HSA_OVERRIDE_GFX_VERSION"] = "10.3.0"
+        # env["HSA_ENABLE_SDMA"] = "0"  # uncomment this if facing errors like in https://github.com/ROCm/ROCm/issues/2616
+        env["FORCE_FULL_PRECISION"] = "yes"  # https://github.com/ROCm/ROCm/issues/2527
+        # FORCE_FULL_PRECISION won't be necessary once this is fixed (and torch2 wheels are released for ROCm 6.2): https://github.com/pytorch/pytorch/issues/132570#issuecomment-2313071756
+    elif any(device_name.startswith("Vega 2") for device_name in device_names):  # Radeon VII etc
+        print("[INFO] Applying Vega 20 settings")
+        env["HSA_OVERRIDE_GFX_VERSION"] = "9.0.6"
+    elif any(device_name.startswith("Vega 1") for device_name in device_names):  # Radeon RX Vega 56 etc
+        print("[INFO] Applying Vega 10 settings")
+        env["HSA_OVERRIDE_GFX_VERSION"] = "9.0.0"
+        env["FORCE_FULL_PRECISION"] = "yes"
+    elif any(device_name.startswith("Ellesmere") for device_name in device_names):  # RX 570, 580, 590, Polaris etc
+        print("[INFO] Applying Ellesmere settings")
+        env["HSA_OVERRIDE_GFX_VERSION"] = "8.0.3"  # https://github.com/ROCm/ROCm/issues/1659
+        env["ROC_ENABLE_PRE_VEGA"] = "1"
+    else:
+        env["ROC_ENABLE_PRE_VEGA"] = "1"
+        print(f"[WARNING] Unrecognized AMD graphics card: {device_names}")
+        return
+
+    num_devices = len(device_names)
+    env["HIP_VISIBLE_DEVICES"] = ",".join(str(i) for i in range(num_devices))
+
+    _set_env_vars(env)
+
+
+def _set_env_vars(env):
+    for k, v in env.items():
+        print(f"[INFO] Setting env variable {k}={v}")
+        os.environ[k] = v

torchruntime/consts.py

@@ -0,0 +1,5 @@
+CONTACT_LINK = "https://github.com/easydiffusion/torchruntime"
+
+AMD = "1002"
+NVIDIA = "10de"
+INTEL = "8086"

torchruntime/device_db.py

@@ -0,0 +1,138 @@
+import os
+import re
+import json
+import sqlite3
+import platform
+import subprocess
+
+DEVICE_DB_FILE = "gpu_pci_ids.db"  # this file will only include AMD, NVIDIA and Discrete Intel GPUs
+
+os_name = platform.system()
+
+
+def get_windows_output():
+    try:
+        command = ["powershell", "-Command", "Get-WmiObject Win32_VideoController | ForEach-Object { $_.PNPDeviceID }"]
+        return subprocess.check_output(command, text=True, stderr=subprocess.DEVNULL)
+    except subprocess.CalledProcessError:
+        return ""
+
+
+def get_linux_output():
+    try:
+        return subprocess.check_output(["lspci", "-nn"], text=True)
+    except FileNotFoundError:
+        return ""
+
+
+def get_macos_output():
+    try:
+        return subprocess.check_output(["system_profiler", "-json", "SPDisplaysDataType"], text=True)
+    except subprocess.CalledProcessError:
+        return ""
+
+
+def parse_windows_output(output):
+    pci_ids = set()
+    for line in output.splitlines():
+        match = re.search(r"VEN_(\w+)&DEV_(\w+)", line, re.IGNORECASE)
+        if match:
+            vendor_id = match.group(1).lower()
+            device_id = match.group(2).lower()
+            pci_ids.add((vendor_id, device_id))
+    return list(pci_ids)
+
+
+def parse_linux_output(output):
+    pci_ids = set()
+    for line in output.splitlines():
+        match = re.search(r"\[(\w+):(\w+)\]", line)
+        if match:
+            vendor_id = match.group(1).lower()
+            device_id = match.group(2).lower()
+            pci_ids.add((vendor_id, device_id))
+    return list(pci_ids)
+
+
+def parse_macos_output(output):
+    pci_ids = set()
+    try:
+        data = json.loads(output)
+        displays = data.get("SPDisplaysDataType", [])
+        for display in displays:
+            vendor_raw = display.get("spdisplays_vendor", "")
+            device_id_raw = display.get("spdisplays_device-id", "")
+            if device_id_raw and vendor_raw:
+                device_id = device_id_raw.replace("0x", "").lower()
+                if "Intel" in vendor_raw:
+                    vendor_id = "8086"
+                else:
+                    match = re.search(r"\((0x\w+)\)", vendor_raw)
+                    if match:
+                        vendor_id = match.group(1).replace("0x", "").lower()
+                    else:
+                        continue
+                pci_ids.add((vendor_id, device_id))
+    except json.JSONDecodeError:
+        pass
+    return list(pci_ids)
+
+
+def get_pci_ids():
+    if os_name == "Windows":
+        output = get_windows_output()
+        return parse_windows_output(output)
+    elif os_name == "Linux":
+        output = get_linux_output()
+        return parse_linux_output(output)
+    elif os_name == "Darwin":  # macOS
+        output = get_macos_output()
+        return parse_macos_output(output)
+    else:
+        return []
+
+
+def get_device_infos(pci_ids):
+    """
+    Reads the given SQLite database file and queries the `pci_ids` table
+    for matching vendor_id and device_id. Returns a list of tuples containing
+    (vendor_id, vendor_name, device_id, device_name).
+
+    Args:
+        db_file_name (str): Path to the SQLite database file.
+        pci_ids (list of tuples): List of (vendor_id, device_id) pairs to match.
+
+    Returns:
+        list of tuples: List of (vendor_id, vendor_name, device_id, device_name).
+    """
+    result = []
+
+    # Establish connection to the database
+    db_path = os.path.join(os.path.dirname(__file__), DEVICE_DB_FILE)
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    try:
+        # Create a query to retrieve matching rows
+        query = """
+        SELECT vendor_id, vendor_name, device_id, device_name
+        FROM pci_ids
+        WHERE vendor_id = ? AND device_id = ?
+        """
+
+        # Execute query for each (vendor_id, device_id) in pci_ids
+        for vendor_id, device_id in pci_ids:
+            cursor.execute(query, (vendor_id, device_id))
+            rows = cursor.fetchall()
+            result.extend(rows)
+
+    finally:
+        # Close the database connection
+        conn.close()
+
+    return result
+
+
+def get_discrete_gpus():
+    pci_ids = get_pci_ids()
+    return get_device_infos(pci_ids)

torchruntime/installer.py

@@ -0,0 +1,98 @@
+import re
+import sys
+import platform
+import subprocess
+
+from .consts import CONTACT_LINK
+from .device_db import get_discrete_gpus
+from .platform_detection import get_torch_platform
+
+os_name = platform.system()
+
+PIP_PREFIX = [sys.executable, "-m", "pip", "install"]
+CUDA_REGEX = re.compile(r"^cu[\d+]")
+
+
+def get_install_commands(torch_platform, packages):
+    """
+    Generates pip installation commands for PyTorch and related packages based on the specified platform.
+
+    Args:
+        torch_platform (str): Target platform for PyTorch. Must be one of:
+            - "cpu"
+            - "cuXXX" (e.g., "cu112", "cu126")
+            - "rocmXXX" (e.g., "rocm4.2", "rocm6.2")
+            - "xpu"
+            - "directml"
+            - "ipex"
+        packages (list of str): List of package names (and optionally versions in pip format). Examples:
+            - ["torch", "torchvision"]
+            - ["torch>=2.0", "torchaudio==0.16.0"]
+
+    Returns:
+        list of list of str: Each sublist contains a pip install command (excluding the `pip install` prefix).
+            Examples:
+            - [["torch", "--index-url", "https://foo.com/whl"]]
+            - [["torch-directml"], ["torch", "torchvision"]]
+
+    Raises:
+        ValueError: If an unsupported platform is provided.
+
+    Notes:
+        - For "xpu" on Windows, if torchvision or torchaudio are included, the function switches to nightly builds.
+        - For "directml", the "torch-directml" package is returned as part of the installation commands.
+        - For "ipex", the "intel-extension-for-pytorch" package is returned as part of the installation commands.
+    """
+    if not packages:
+        packages = ["torch", "torchaudio", "torchvision"]
+
+    if torch_platform == "cpu":
+        return [packages]
+
+    if CUDA_REGEX.match(torch_platform) or torch_platform.startswith("rocm"):
+        index_url = f"https://download.pytorch.org/whl/{torch_platform}"
+        return [packages + ["--index-url", index_url]]
+
+    if torch_platform == "xpu":
+        if os_name == "Windows" and ("torchvision" in packages or "torchaudio" in packages):
+            print(
+                f"[WARNING] The preview build of 'xpu' on Windows currently only supports torch, not torchvision/torchaudio. "
+                f"torch-installer will instead use the nightly build, to get the 'xpu' version of torchaudio and torchvision as well. "
+                f"Please contact torch-installer if this is no longer accurate: {CONTACT_LINK}"
+            )
+            index_url = f"https://download.pytorch.org/whl/nightly/{torch_platform}"
+        else:
+            index_url = f"https://download.pytorch.org/whl/test/{torch_platform}"
+
+        return [packages + ["--index-url", index_url]]
+
+    if torch_platform == "directml":
+        return [["torch-directml"], packages]
+
+    if torch_platform == "ipex":
+        return [packages, ["intel-extension-for-pytorch"]]
+
+    raise ValueError(f"Unsupported platform: {torch_platform}")
+
+
+def get_pip_commands(cmds):
+    assert not any(cmd is None for cmd in cmds)
+    return [PIP_PREFIX + cmd for cmd in cmds]
+
+
+def run_commands(cmds):
+    for cmd in cmds:
+        print("> ", cmd)
+        subprocess.run(cmd)
+
+
+def install(packages=[]):
+    """
+    packages: a list of strings with package names (and optionally their versions in pip-format). e.g. ["torch", "torchvision"] or ["torch>=2.0", "torchaudio==0.16.0"]. Defaults to ["torch", "torchvision", "torchaudio"].
+    """
+
+    discrete_gpu_infos = get_discrete_gpus()
+    torch_platform = get_torch_platform(discrete_gpu_infos)
+    cmds = get_install_commands(torch_platform, packages)
+    cmds = get_pip_commands(cmds)
+    run_commands(cmds)

torchruntime/platform_detection.py

@@ -0,0 +1,115 @@
+import sys
+import platform
+
+from .consts import AMD, INTEL, NVIDIA, CONTACT_LINK
+
+os_name = platform.system()
+arch = platform.machine().lower()
+py_version = sys.version_info
+
+
+def get_torch_platform(discrete_gpu_infos):
+    """
+    Determine the appropriate PyTorch platform to use based on the system architecture, OS, and GPU information.
+
+    Args:
+        discrete_gpu_infos (list of tuples): A list where each tuple represents a GPU. Each tuple contains:
+            - vendor_id (int): The vendor ID of the GPU (e.g., NVIDIA, AMD, INTEL constants).
+            - other details (e.g., model, memory, etc., not used directly in this function).
+
+    Returns:
+        str: A string representing the platform to use. Possible values:
+            - "cpu": No discrete GPUs or unsupported configuration.
+            - "cuXXX": NVIDIA CUDA version (e.g., "cu124").
+            - "rocmXXX": AMD ROCm version (e.g., "rocm6.2").
+            - "directml": DirectML for AMD or Intel GPUs on Windows.
+            - "ipex": Intel Extension for PyTorch for Linux.
+            - "xpu": Intel's backend for PyTorch.
+
+    Raises:
+        NotImplementedError: For unsupported architectures, OS-GPU combinations, or multiple GPU vendors.
+        Warning: Outputs warnings for deprecated Python versions or fallback configurations.
+    """
+
+    VALID_ARCHS = {
+        "Windows": {"amd64"},
+        "Linux": {"x86_64", "aarch64"},
+        "Darwin": {"x86_64", "arm64"},
+    }
+
+    if arch not in VALID_ARCHS[os_name]:
+        raise NotImplementedError(
+            f"torch is not currently available for {os_name} on {arch} architecture! If this is no longer true, please contact torch-installer at {CONTACT_LINK}"
+        )
+
+    if len(discrete_gpu_infos) == 0:
+        return "cpu"
+
+    vendor_ids = set(vendor_id for vendor_id, *_ in discrete_gpu_infos)
+
+    if len(vendor_ids) > 1:
+        device_names = list(vendor_name + " " + device_name for _, vendor_name, _, device_name in discrete_gpu_infos)
+        raise NotImplementedError(
+            f"torch-installer does not currently support multiple graphics card manufacturers on the same computer: {device_names}! Please contact torch-installer at {CONTACT_LINK} with details about your hardware."
+        )
+
+    vendor_id = vendor_ids.pop()
+    if vendor_id == AMD:
+        if os_name == "Windows":
+            return "directml"
+        elif os_name == "Linux":
+            device_names = set(device_name for *_, device_name in discrete_gpu_infos)
+            if any(
+                device_name.startswith("Navi 3") or device_name.startswith("Navi 2") for device_name in device_names
+            ):
+                if py_version < (3, 9):
+                    print(
+                        "[WARNING] Support for Python 3.8 was dropped in ROCm 6.2. torch-installer will default to using ROCm 6.1 instead, but consider switching to a newer Python version to use the latest ROCm!"
+                    )
+                    return "rocm6.1"
+                return "rocm6.2"
+            elif any(device_name.startswith("Navi 1") for device_name in device_names):
+                return "rocm5.2"
+            elif any(
+                device_name.startswith("Vega 1") or device_name.startswith("Vega 2") for device_name in device_names
+            ):
+                return "rocm5.7"
+            elif any(device_name.startswith("Ellesmere") for device_name in device_names):
+                return "rocm4.2"
+
+            print(
+                f"[WARNING] Unsupported AMD graphics card: {device_names}. If this is a recent graphics card (less than 8 years old), please contact torch-installer at {CONTACT_LINK} with details about your hardware."
+            )
+            return "cpu"
+        elif os_name == "Darwin":
+            return "rocm4.2"
+    elif vendor_id == NVIDIA:
+        if os_name in ("Windows", "Linux"):
+            return "cu124"
+        elif os_name == "Darwin":
+            raise NotImplementedError(
+                f"torch-installer does not currently support NVIDIA graphics cards on Macs! Please contact torch-installer at {CONTACT_LINK}"
+            )
+    elif vendor_id == INTEL:
+        if os_name == "Windows":
+            if py_version < (3, 9):
+                print(
+                    "[WARNING] Support for Python 3.8 was dropped in torch 2.5, which supports a higher-performance 'xpu' backend for Intel. torch-installer will default to using 'directml' instead, but consider switching to a newer Python version to use the latest 'xpu' backend for Intel!"
+                )
+                return "directml"
+            return "xpu"
+        elif os_name == "Linux":
+            if py_version < (3, 9):
+                print(
+                    "[WARNING] Support for Python 3.8 was dropped in torch 2.5, which supports a higher-performance 'xpu' backend for Intel. torch-installer will default to using 'intel-extension-for-pytorch' instead, but consider switching to a newer Python version to use the latest 'xpu' backend for Intel!"
+                )
+                return "ipex"
+            return "xpu"
+        else:
+            raise NotImplementedError(
+                f"torch-installer does not currently support Intel graphics cards on Macs! Please contact torch-installer at {CONTACT_LINK}"
+            )
+
+    print(f"Unrecognized vendor: {discrete_gpu_infos}")
+
+    return "cpu"

torchruntime/tests/test_configure.py

@@ -0,0 +1,137 @@
+import os
+import pytest
+from torchruntime.configure import set_rocm_env_vars
+from torchruntime.consts import AMD
+
+
+def create_gpu_info(device_id, device_name):
+    return (AMD, "Advanced Micro Devices, Inc. [AMD/ATI]", device_id, device_name)
+
+
+@pytest.fixture(autouse=True)
+def clean_env():
+    # Remove relevant environment variables before each test
+    env_vars = [
+        "HSA_OVERRIDE_GFX_VERSION",
+        "HIP_VISIBLE_DEVICES",
+        "ROC_ENABLE_PRE_VEGA",
+        "HSA_ENABLE_SDMA",
+        "FORCE_FULL_PRECISION",
+    ]
+
+    # Store original values
+    original_values = {}
+    for var in env_vars:
+        if var in os.environ:
+            original_values[var] = os.environ[var]
+            del os.environ[var]
+
+    yield
+
+    # Restore original values and remove any new ones
+    for var in env_vars:
+        if var in os.environ and var not in original_values:
+            del os.environ[var]
+        elif var in original_values:
+            os.environ[var] = original_values[var]
+
+
+def test_navi_3_settings():
+    gpus = [create_gpu_info("123", "Navi 31 XTX")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert os.environ.get("HSA_OVERRIDE_GFX_VERSION") == "11.0.0"
+    assert os.environ.get("HIP_VISIBLE_DEVICES") == "0"
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+    assert "FORCE_FULL_PRECISION" not in os.environ
+
+
+def test_navi_2_settings():
+    gpus = [create_gpu_info("123", "Navi 21 XTX")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert os.environ.get("HSA_OVERRIDE_GFX_VERSION") == "10.3.0"
+    assert os.environ.get("HIP_VISIBLE_DEVICES") == "0"
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+    assert "FORCE_FULL_PRECISION" not in os.environ
+
+
+def test_navi_1_settings():
+    gpus = [create_gpu_info("123", "Navi 14")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert os.environ.get("HSA_OVERRIDE_GFX_VERSION") == "10.3.0"
+    assert os.environ.get("HIP_VISIBLE_DEVICES") == "0"
+    assert os.environ.get("FORCE_FULL_PRECISION") == "yes"
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+
+
+def test_vega_2_settings():
+    gpus = [create_gpu_info("123", "Vega 20 Radeon VII")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert os.environ.get("HSA_OVERRIDE_GFX_VERSION") == "9.0.6"
+    assert os.environ.get("HIP_VISIBLE_DEVICES") == "0"
+    assert "FORCE_FULL_PRECISION" not in os.environ
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+
+
+def test_vega_1_settings():
+    gpus = [create_gpu_info("123", "Vega 10")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert os.environ.get("HSA_OVERRIDE_GFX_VERSION") == "9.0.0"
+    assert os.environ.get("HIP_VISIBLE_DEVICES") == "0"
+    assert os.environ.get("FORCE_FULL_PRECISION") == "yes"
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+
+
+def test_ellesmere_settings():
+    gpus = [create_gpu_info("123", "Ellesmere RX 580")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert os.environ.get("HSA_OVERRIDE_GFX_VERSION") == "8.0.3"
+    assert os.environ.get("ROC_ENABLE_PRE_VEGA") == "1"
+    assert os.environ.get("HIP_VISIBLE_DEVICES") == "0"
+    assert "FORCE_FULL_PRECISION" not in os.environ
+
+
+def test_unknown_gpu_settings():
+    gpus = [create_gpu_info("123", "Unknown GPU")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+    assert "HIP_VISIBLE_DEVICES" not in os.environ
+    assert "HSA_OVERRIDE_GFX_VERSION" not in os.environ
+    assert "FORCE_FULL_PRECISION" not in os.environ
+
+
+def test_multiple_gpus_same_type():
+    gpus = [create_gpu_info("123", "Navi 31 XTX"), create_gpu_info("124", "Navi 31 XT")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert os.environ.get("HSA_OVERRIDE_GFX_VERSION") == "11.0.0"
+    assert os.environ.get("HIP_VISIBLE_DEVICES") == "0,1"
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+    assert "FORCE_FULL_PRECISION" not in os.environ
+
+
+def test_multiple_gpus_mixed_types():
+    gpus = [create_gpu_info("123", "Navi 31 XTX"), create_gpu_info("124", "Navi 21 XT")]
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    # Should use Navi 3 settings since at least one GPU is Navi 3
+    assert os.environ.get("HSA_OVERRIDE_GFX_VERSION") == "11.0.0"
+    assert os.environ.get("HIP_VISIBLE_DEVICES") == "0,1"
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+    assert "FORCE_FULL_PRECISION" not in os.environ
+
+
+def test_empty_gpu_list():
+    gpus = []
+    set_rocm_env_vars(gpus, "rocm6.2")
+
+    assert "ROC_ENABLE_PRE_VEGA" not in os.environ
+    assert "HIP_VISIBLE_DEVICES" not in os.environ
+    assert "HSA_OVERRIDE_GFX_VERSION" not in os.environ
+    assert "FORCE_FULL_PRECISION" not in os.environ

torchruntime/tests/test_device_db.py

@@ -0,0 +1,50 @@
+from torchruntime.device_db import parse_windows_output, parse_linux_output, parse_macos_output
+
+
+def test_parse_windows_output():
+    output = """
+    PCI\\VEN_8086&DEV_591B&SUBSYS_2212103C&REV_04
+    PCI\\VEN_10DE&DEV_1C82&SUBSYS_37131462&REV_A1
+    PCI\\VEN_10DE&DEV_2504&SUBSYS_881D1043&REV_A1\\4&22AF55FA&0&0008
+    """
+    expected = [("8086", "591b"), ("10de", "1c82"), ("10de", ("2504"))]
+    assert sorted(parse_windows_output(output)) == sorted(expected)
+
+
+def test_parse_linux_output():
+    output = """
+    00:02.0 VGA compatible controller: Intel Corporation HD Graphics 620 (rev 02) [8086:5916]
+    01:00.0 3D controller: NVIDIA Corporation GP108M [GeForce MX150] (rev a1) [10de:1d10]
+    """
+    expected = [("8086", "5916"), ("10de", "1d10")]
+    assert sorted(parse_linux_output(output)) == sorted(expected)
+
+
+def test_parse_macos_output():
+    output = """
+    {
+        "SPDisplaysDataType": [
+            {
+                "spdisplays_vendor": "Intel",
+                "spdisplays_device-id": "0x5916"
+            },
+            {
+                "spdisplays_vendor": "NVIDIA (0x10de)",
+                "spdisplays_device-id": "0x1c82"
+            }
+        ]
+    }
+    """
+    expected = [("8086", "5916"), ("10de", "1c82")]
+    assert sorted(parse_macos_output(output)) == sorted(expected)
+
+
+def test_parse_macos_output_invalid_json():
+    output = "{ invalid_json: true }"
+    assert parse_macos_output(output) == []
+
+
+def test_empty_outputs():
+    assert parse_windows_output("") == []
+    assert parse_linux_output("") == []
+    assert parse_macos_output("") == []

torchruntime/tests/test_device_db_integration.py

@@ -0,0 +1,50 @@
+# Integration test, which connects to the database and checks for some common devices
+
+from torchruntime.device_db import get_device_infos, DEVICE_DB_FILE
+
+
+def test_db_file_exists():
+    import os
+    from torchruntime import device_db
+
+    db_path = os.path.join(os.path.dirname(device_db.__file__), DEVICE_DB_FILE)
+    assert os.path.exists(db_path)
+
+
+def test_get_single_device():
+    """Test retrieving a single device."""
+    result = get_device_infos([("8086", "56a7")])
+    assert len(result) == 1
+    assert result[0] == ("8086", "Intel Corporation", "56a7", "DG2 [Arc Xe Graphics]")
+
+
+def test_get_multiple_devices():
+    """Test retrieving multiple devices."""
+    input_ids = [("10de", "2786"), ("10de", "2504")]
+    result = get_device_infos(input_ids)
+    assert len(result) == 2
+    assert ("10de", "NVIDIA Corporation", "2786", "AD104 [GeForce RTX 4070]") in result
+    assert ("10de", "NVIDIA Corporation", "2504", "GA106 [GeForce RTX 3060 Lite Hash Rate]") in result
+
+
+def test_get_amd_devices():
+    """Test retrieving AMD devices."""
+    input_ids = [("1002", "9495"), ("1002", "747e")]
+    result = get_device_infos(input_ids)
+    assert len(result) == 2
+    assert ("1002", "Advanced Micro Devices, Inc. [AMD/ATI]", "9495", "RV730 [Radeon HD 4600 AGP Series]") in result
+    assert ("1002", "Advanced Micro Devices, Inc. [AMD/ATI]", "747e", "Navi 32 [Radeon RX 7700 XT / 7800 XT]") in result
+
+
+def test_get_nonexistent_device():
+    """Test retrieving a device that doesn't exist in the database."""
+    result = get_device_infos([("ffff", "ffff")])
+    assert len(result) == 0
+
+
+def test_get_mixed_existing_and_nonexistent():
+    """Test retrieving a mix of existing and non-existing devices."""
+    input_ids = [("8086", "56a7"), ("ffff", "ffff")]  # exists  # doesn't exist
+    result = get_device_infos(input_ids)
+    assert len(result) == 1
+    assert result[0] == ("8086", "Intel Corporation", "56a7", "DG2 [Arc Xe Graphics]")

torchruntime/tests/test_installer.py

@@ -0,0 +1,109 @@
+import sys
+import pytest
+from unittest.mock import patch
+from torchruntime.installer import get_install_commands, get_pip_commands, run_commands
+
+
+def test_empty_args():
+    packages = []
+    result = get_install_commands("cpu", packages)
+    assert result == [["torch", "torchaudio", "torchvision"]]
+
+
+def test_cpu_platform():
+    packages = ["torch", "torchvision"]
+    result = get_install_commands("cpu", packages)
+    assert result == [packages]
+
+
+def test_cuda_platform():
+    packages = ["torch", "torchvision"]
+    result = get_install_commands("cu112", packages)
+    expected_url = "https://download.pytorch.org/whl/cu112"
+    assert result == [packages + ["--index-url", expected_url]]
+
+
+def test_rocm_platform():
+    packages = ["torch", "torchvision"]
+    result = get_install_commands("rocm4.2", packages)
+    expected_url = "https://download.pytorch.org/whl/rocm4.2"
+    assert result == [packages + ["--index-url", expected_url]]
+
+
+def test_xpu_platform_windows_with_torch_only(monkeypatch):
+    monkeypatch.setattr("torchruntime.installer.os_name", "Windows")
+    packages = ["torch"]
+    result = get_install_commands("xpu", packages)
+    expected_url = "https://download.pytorch.org/whl/test/xpu"
+    assert result == [packages + ["--index-url", expected_url]]
+
+
+def test_xpu_platform_windows_with_torchvision(monkeypatch, capsys):
+    monkeypatch.setattr("torchruntime.installer.os_name", "Windows")
+    packages = ["torch", "torchvision"]
+    result = get_install_commands("xpu", packages)
+    expected_url = "https://download.pytorch.org/whl/nightly/xpu"
+    assert result == [packages + ["--index-url", expected_url]]
+    captured = capsys.readouterr()
+    assert "[WARNING]" in captured.out
+
+
+def test_xpu_platform_linux(monkeypatch):
+    monkeypatch.setattr("torchruntime.installer.os_name", "Linux")
+    packages = ["torch", "torchvision"]
+    result = get_install_commands("xpu", packages)
+    expected_url = "https://download.pytorch.org/whl/test/xpu"
+    assert result == [packages + ["--index-url", expected_url]]
+
+
+def test_directml_platform():
+    packages = ["torch", "torchvision"]
+    result = get_install_commands("directml", packages)
+    assert result == [["torch-directml"], packages]
+
+
+def test_ipex_platform():
+    packages = ["torch", "torchvision"]
+    result = get_install_commands("ipex", packages)
+    assert result == [packages, ["intel-extension-for-pytorch"]]
+
+
+def test_unsupported_platform():
+    packages = ["torch", "torchvision"]
+    with pytest.raises(ValueError, match="Unsupported platform: unknown"):
+        get_install_commands("unknown", packages)
+
+
+def test_get_pip_commands_valid():
+    cmds = [["package1"], ["package2", "--upgrade"]]
+    expected = [
+        [sys.executable, "-m", "pip", "install", "package1"],
+        [sys.executable, "-m", "pip", "install", "package2", "--upgrade"],
+    ]
+
+    result = get_pip_commands(cmds)
+    assert result == expected
+
+
+def test_get_pip_commands_none_input():
+    cmds = [["package1"], None]
+    with pytest.raises(AssertionError):
+        get_pip_commands(cmds)
+
+
+# Test suite for run_commands
+def test_run_commands():
+    cmds = [
+        [sys.executable, "-m", "pip", "install", "package1"],
+        [sys.executable, "-m", "pip", "install", "package2", "--upgrade"],
+    ]
+
+    with patch("subprocess.run") as mock_run:
+        run_commands(cmds)
+
+        # Ensure subprocess.run was called for each command
+        assert mock_run.call_count == len(cmds)
+
+        # Check that subprocess.run was called with the correct arguments
+        mock_run.assert_any_call(cmds[0])
+        mock_run.assert_any_call(cmds[1])

torchruntime/tests/test_platform_detection.py

@@ -0,0 +1,164 @@
+import pytest
+from torchruntime.platform_detection import get_torch_platform, AMD, NVIDIA, INTEL, os_name, arch, py_version
+
+
+def test_no_discrete_gpus_windows(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Windows")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "amd64")
+    assert get_torch_platform([]) == "cpu"
+
+
+def test_no_discrete_gpus_linux(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    assert get_torch_platform([]) == "cpu"
+
+
+def test_no_discrete_gpus_mac(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Darwin")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "arm64")
+    assert get_torch_platform([]) == "cpu"
+
+
+def test_amd_gpu_windows(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Windows")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "amd64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "Radeon")]
+    assert get_torch_platform(discrete_gpu_infos) == "directml"
+
+
+def test_amd_gpu_navi3_linux(monkeypatch, capsys):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "Navi 31")]
+    expected = "rocm6.1" if py_version < (3, 9) else "rocm6.2"
+    assert get_torch_platform(discrete_gpu_infos) == expected
+    if py_version < (3, 9):
+        captured = capsys.readouterr()
+        assert "Support for Python 3.8 was dropped in ROCm 6.2" in captured.out
+
+
+def test_amd_gpu_navi2_linux(monkeypatch, capsys):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "Navi 22")]
+    expected = "rocm6.1" if py_version < (3, 9) else "rocm6.2"
+    assert get_torch_platform(discrete_gpu_infos) == expected
+    if py_version < (3, 9):
+        captured = capsys.readouterr()
+        assert "Support for Python 3.8 was dropped in ROCm 6.2" in captured.out
+
+
+def test_amd_gpu_navi1_linux(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "Navi 10")]
+    assert get_torch_platform(discrete_gpu_infos) == "rocm5.2"
+
+
+def test_amd_gpu_vega1_linux(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "Vega 10")]
+    assert get_torch_platform(discrete_gpu_infos) == "rocm5.7"
+
+
+def test_amd_gpu_vega2_linux(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "Vega 20")]
+    assert get_torch_platform(discrete_gpu_infos) == "rocm5.7"
+
+
+def test_amd_gpu_ellesmere_linux(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "Ellesmere")]
+    assert get_torch_platform(discrete_gpu_infos) == "rocm4.2"
+
+
+def test_amd_gpu_unsupported_linux(monkeypatch, capsys):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "UnknownModel")]
+    assert get_torch_platform(discrete_gpu_infos) == "cpu"
+    captured = capsys.readouterr()
+    assert "[WARNING] Unsupported AMD graphics card" in captured.out
+
+
+def test_amd_gpu_mac(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Darwin")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "arm64")
+    discrete_gpu_infos = [(AMD, "AMD", 0x1234, "Radeon")]
+    assert get_torch_platform(discrete_gpu_infos) == "rocm4.2"
+
+
+def test_nvidia_gpu_windows(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Windows")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "amd64")
+    discrete_gpu_infos = [(NVIDIA, "NVIDIA", 0x1234, "GeForce")]
+    assert get_torch_platform(discrete_gpu_infos) == "cu124"
+
+
+def test_nvidia_gpu_linux(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(NVIDIA, "NVIDIA", 0x1234, "GeForce")]
+    assert get_torch_platform(discrete_gpu_infos) == "cu124"
+
+
+def test_nvidia_gpu_mac(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Darwin")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "arm64")
+    discrete_gpu_infos = [(NVIDIA, "NVIDIA", 0x1234, "GeForce")]
+    with pytest.raises(NotImplementedError):
+        get_torch_platform(discrete_gpu_infos)
+
+
+def test_intel_gpu_windows(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Windows")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "amd64")
+    discrete_gpu_infos = [(INTEL, "Intel", 0x1234, "Iris")]
+    expected = "directml" if py_version < (3, 9) else "xpu"
+    assert get_torch_platform(discrete_gpu_infos) == expected
+
+
+def test_intel_gpu_linux(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "x86_64")
+    discrete_gpu_infos = [(INTEL, "Intel", 0x1234, "Iris")]
+    expected = "ipex" if py_version < (3, 9) else "xpu"
+    assert get_torch_platform(discrete_gpu_infos) == expected
+
+
+def test_intel_gpu_mac(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Darwin")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "arm64")
+    discrete_gpu_infos = [(INTEL, "Intel", 0x1234, "Iris")]
+    with pytest.raises(NotImplementedError):
+        get_torch_platform(discrete_gpu_infos)
+
+
+def test_multiple_gpu_vendors(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Windows")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "amd64")
+    discrete_gpu_infos = [
+        (AMD, "AMD", 0x1234, "Radeon"),
+        (NVIDIA, "NVIDIA", 0x5678, "GeForce"),
+    ]
+    with pytest.raises(NotImplementedError):
+        get_torch_platform(discrete_gpu_infos)
+
+
+def test_unsupported_architecture(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Linux")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "sparc")
+    with pytest.raises(NotImplementedError):
+        get_torch_platform([])
+
+
+def test_unrecognized_gpu_vendor(monkeypatch):
+    monkeypatch.setattr("torchruntime.platform_detection.os_name", "Windows")
+    monkeypatch.setattr("torchruntime.platform_detection.arch", "amd64")
+    discrete_gpu_infos = [("9999", "UnknownVendor", 0x1234, "Unknown")]
+    assert get_torch_platform(discrete_gpu_infos) == "cpu"

torchruntime-1.0.2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 easydiffusion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

torchruntime-1.0.2.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.2
+Name: torchruntime
+Version: 1.0.2
+Summary: Meant for app developers. A convenient way to install and configure the appropriate version of PyTorch on the user's computer, based on the OS and GPU manufacturer and model number.
+Author-email: cmdr2 <secondary.cmdr2@gmail.com>
+Project-URL: Homepage, https://github.com/easydiffusion/torchruntime
+Project-URL: Bug Tracker, https://github.com/easydiffusion/torchruntime/issues
+Keywords: torch,ai,ml,llm,installer,runtime
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# torchruntime
+[![Discord Server](https://img.shields.io/discord/1014774730907209781?label=Discord)](https://discord.com/invite/u9yhsFmEkB)
+
+**torchruntime** is a lightweight package for automatically installing the appropriate variant of PyTorch on a user's computer, based on their OS, and GPU manufacturer and GPU model.
+
+This package is used by [Easy Diffusion](https://github.com/easydiffusion/easydiffusion), but you're welcome to use it as well. It's useful for developers who make PyTorch-based apps that target users with NVIDIA, AMD and Intel graphics cards (as well as CPU-only usage), on Windows, Mac and Linux.
+
+### Why?
+It lets you treat PyTorch as a single dependency (like it should be), and lets you assume that each user will get the most-performant variant of PyTorch suitable for their computer's OS and hardware.
+
+It deals with the complexity of the variety of torch builds and configurations required for CUDA, AMD (ROCm, DirectML), Intel (xpu/DirectML/ipex), and CPU-only.
+
+**Compatibility table**: [Click here](#compatibility-table) to see the supported graphics cards and operating systems.
+
+# Installation
+Supports Windows, Linux, and Mac.
+
+`pip install torchruntime`
+
+## Usage
+### Step 1. Install the appropriate variant of PyTorch
+*This command should be run on the user's computer, or while creating platform-specific builds:*
+
+`python -m torchruntime install`
+
+This will install `torch`, `torchvision`, and `torchaudio`, and will decide the variant based on the user's OS, GPU manufacturer and GPU model number. See [customizing packages](#customizing-packages) for more options.
+
+### Step 2. Initialize torch
+This should be run inside your program, to initialize the required environment variables (if any) for the variant of torch being used.
+
+```py
+import torchruntime
+
+torchruntime.init_torch()
+```
+
+## Customizing packages
+By default, `python -m torchruntime install` will install the latest available `torch`, `torchvision` and `torchaudio` suitable on the user's platform.
+
+You can customize the packages to install by including their names:
+* For e.g. to install only `torch` and `torchvision`, you can run `python -m torchruntime install torch torchvision`
+* To install specific versions (in pip format), you can run `python -m torchruntime install "torch>2.0" "torchvision==0.20"`
+
+**Note:** If you specify package versions, please keep in mind that the version may not be available to *all* the users on *all* the torch platforms. For e.g. a user with Python 3.8 would not be able to install torch 2.5 (or higher), because torch 2.5 dropped support for Python 3.8.
+
+So in general, it's better to avoid specifying a version unless it really matters to you (or you know what you're doing). Instead, please allow `torchruntime` to pick the latest-possible version for the user.
+
+# Compatibility table
+The list of platforms on which `torchruntime` can install a working variant of PyTorch.
+
+**Note:** *This list is based on user feedback (since I don't have all the cards). Please let me know if your card is supported (or not) by opening a pull request or issue or messaging on [Discord](https://discord.com/invite/u9yhsFmEkB) (with supporting logs).*
+
+**CPU-only:**
+
+| OS  | Supported?| Notes  |
+|---|---|---|
+| Windows  | ✅ Yes  | x86_64  |
+| Linux  | ✅ Yes  | x86_64 and aarch64  |
+| Mac (M1/M2/M3/M4)  | ✅ Yes  | arm64. `mps` backend  |
+| Mac (Intel)  | ✅ Yes  | x86_64. Stopped after `torch 2.2.2`  |
+
+**NVIDIA:**
+
+| Series  | Supported? | OS | Notes  |
+|---|---|---|---|
+| 40xx  | ✅ Yes  | Win/Linux  | Uses CUDA 124  |
+| 30xx  | ✅ Yes  | Win/Linux  | Uses CUDA 124  |
+| 20xx  | ✅ Yes  | Win/Linux  | Uses CUDA 124  |
+| 10xx/16xx  | ✅ Yes  | Win/Linux  | Uses CUDA 124. Full-precision required on 16xx series  |
+
+**AMD:**
+
+| Series  | Supported? | OS   | Notes  |
+|---|---|---|---|
+| 7xxx  | ✅ Yes  | Win/Linux    | Navi3/RDNA3 (gfx110x). ROCm 6.2 on Linux. DirectML on Windows  |
+| 6xxx  | ✅ Yes  | Win/Linux    | Navi2/RDNA2 (gfx103x). ROCm 6.2 on Linux. DirectML on Windows  |
+| 5xxx  | ✅ Yes  | Win/Linux    | Navi1/RDNA1 (gfx101x). Full-precision required. DirectML on Windows. Linux only supports upto ROCm 5.2. Waiting for [this](https://github.com/pytorch/pytorch/issues/132570#issuecomment-2313071756) for ROCm 6.2 support.  |
+| 5xxx on Intel Mac  | ❓ Untested (WIP)  | Intel Mac  | gfx101x. Implemented but need testers, please message on [Discord](https://discord.com/invite/u9yhsFmEkB) |
+| 4xxxG/Radeon VII  | ✅ Yes  | Win/Linux  | Vega 20 gfx906. Need testers for Windows, please message on [Discord](https://discord.com/invite/u9yhsFmEkB) |
+| 2xxxG/Radeon RX Vega 56  | ❓ Untested (WIP)  | N/A  | Vega 10 gfx900. Implemented but need testers, please message on [Discord](https://discord.com/invite/u9yhsFmEkB) |
+| 5xx/Polaris  | ❓ Untested (WIP)  | N/A  | gfx80x. Implemented but need testers, please message on [Discord](https://discord.com/invite/u9yhsFmEkB) |
+
+**Apple:**
+
+| Series  | Supported? |Notes  |
+|---|---|---|
+| M1/M2/M3/M4  | ✅ Yes  | 'mps' backend  |
+| AMD on Intel Mac  | ❓ Untested (WIP)  | Implemented but need testers, please message on [Discord](https://discord.com/invite/u9yhsFmEkB) |
+
+**Intel:**
+
+| Series  | Supported? | OS | Notes  |
+|---|---|---|---|
+| Arc  | ❓ Untested (WIP)  | Win/Linux  | Implemented but need testers, please message on [Discord](https://discord.com/invite/u9yhsFmEkB). Backends: 'xpu' or DirectML or [ipex](https://github.com/intel/intel-extension-for-pytorch) |
+
+
+# FAQ
+## Why can't I just run 'pip install torch'?
+`pip install torch` installs the CPU-only version of torch, so it won't utilize your GPU's capabilities.
+
+## Why can't I just install torch-for-ROCm directly to support AMD?
+Different models of AMD cards require different LLVM targets, and sometimes different ROCm versions. And ROCm currently doesn't work on Windows, so AMD on Windows is best served (currently) with DirectML.
+
+And plenty of AMD cards work with ROCm (even when they aren't in the official list of supported cards). Information about these cards (for e.g. the LLVM target to use) is pretty scattered.
+
+`torchruntime` deals with this complexity for your convenience.
+
+# Contributing
+📢 I'm looking for contributions in these specific areas:
+- More testing on consumer AMD GPUs.
+- More support for older AMD GPUs. Explore: Compile and host PyTorch wheels and rocm (on GitHub) for older AMD gpus (e.g. 580/590/Polaris) with the required patches.
+- Intel GPUs.
+- Testing on professional AMD GPUs (e.g. the Instinct series).
+- An easy-to-run benchmark script (that people can run to check the level of compatibility on their platform).
+
+Please message on the [Discord community](https://discord.com/invite/u9yhsFmEkB) if you have AMD or Intel GPUs, and would like to help with testing or adding support for them! Thanks!
+
+# Credits
+* Code contributors on [Easy Diffusion](https://github.com/easydiffusion/easydiffusion).
+* Users on [Easy Diffusion's Discord](https://discord.com/invite/u9yhsFmEkB) who've helped with testing on various GPUs.
+* [PCI Database](https://github.com/pciutils/pciids/) automatically generated from the PCI ID Database at http://pci-ids.ucw.cz
+
+# More resources
+* [AMD GPU LLVM Architectures](https://web.archive.org/web/20241228163540/https://llvm.org/docs/AMDGPUUsage.html#processors)
+* [Status of ROCm support for AMD Navi 1](https://github.com/ROCm/ROCm/issues/2527)
+* [Torch support for ROCm 6.2 on AMD Navi 1](https://github.com/pytorch/pytorch/issues/132570#issuecomment-2313071756)
+* [ROCmLibs-for-gfx1103-AMD780M-APU](https://github.com/likelovewant/ROCmLibs-for-gfx1103-AMD780M-APU)

torchruntime-1.0.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+torchruntime/__init__.py,sha256=m5-DZXo3-hf9yhDiS8f9TfyQC6ztpE7VHdo1BRQmFE8,65
+torchruntime/__main__.py,sha256=Cf7g3YWVtxqSFSGp6KLeg65JPYOz4QE8atk7gP_SeTM,1449
+torchruntime/configure.py,sha256=MJmxkDBzdyHoGWRmeP9Pgsx4jdySVrTsXk5vnmwLDSA,3983
+torchruntime/consts.py,sha256=-N9FORwsESh8e20xaX3l-Ord05BmNrPFmsdk6iwv0Rg,108
+torchruntime/device_db.py,sha256=VadbEm_kJgNNyhj7Y-LLKdWxZUKFU3-MjDU5xHiBYSo,4154
+torchruntime/gpu_pci_ids.db,sha256=j9LzoFILdTn-149K9MY-SIZk7HUxIXzPd7dl2ybUoZk,221184
+torchruntime/installer.py,sha256=Mfqkv8Eh1XTD5e8ycqtQ3Cjv0Db6NBpBgeZsUciYKJE,3689
+torchruntime/platform_detection.py,sha256=QuBNvS813Dk95KbOiRiaYBcsrkCtI39ftBpIE8n7zsI,5364
+torchruntime/tests/test_configure.py,sha256=emiHac_MnCLq7_V82ActNUgZI37v4ozlENG-jIydGiM,4581
+torchruntime/tests/test_device_db.py,sha256=iAWAbJSJLZS9DCt59SSQVoaKSxoDRnTPrIwCVcKiCfI,1590
+torchruntime/tests/test_device_db_integration.py,sha256=Vwk9z3HG8A8T9j-tWUseWDy_Te9_jjlhco-LOTDI06A,1955
+torchruntime/tests/test_installer.py,sha256=8bwYGmJihdhjfg8YT6QKqjDnO15B2vXAb3DGrrAbkms,3625
+torchruntime/tests/test_platform_detection.py,sha256=-lo7qPuaP7pPKSCxW3a2CkzWE2EmjUESB7jtFsaj8fU,7335
+torchruntime-1.0.2.dist-info/LICENSE,sha256=wrkpT53J7BEDdUpsh9F-0-1j-LNkStyAubQNYet24BA,1070
+torchruntime-1.0.2.dist-info/METADATA,sha256=QS0jG6u_6RW0V48u82y1rEhmMBLO1cuR0zZB92VtSmQ,8533
+torchruntime-1.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+torchruntime-1.0.2.dist-info/top_level.txt,sha256=8JeRerOboHkQ_Jw_HiZnctS1d4wGHZa9HZJdd0wWRwQ,13
+torchruntime-1.0.2.dist-info/RECORD,,

torchruntime-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

torchruntime-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+torchruntime