Add AMD ROCm/HIP support across installer and hardware detection

studio/backend/core/training/worker.py

@@ -86,6 +86,7 @@ def _probe_causal_conv1d_env() -> dict[str, str] | None:
                     "'python_tag': f'cp{sys.version_info.major}{sys.version_info.minor}', "
                     "'torch_mm': torch_mm, "
                     "'cuda_major': str(int(str(torch.version.cuda).split('.', 1)[0])) if torch.version.cuda else '', "
+                    "'hip_version': str(torch.version.hip) if getattr(torch.version, 'hip', None) else '', "
                     "'cxx11abi': str(torch._C._GLIBCXX_USE_CXX11_ABI).upper()"
                     "}))"
                 ),
@@ -237,28 +238,111 @@ def _install_package_wheel_first(
         else:
             logger.info("No published %s wheel found: %s", display_name, wheel_url)
 
-    _send_status(event_queue, f"Installing {display_name} from PyPI...")
-    pypi_cmd = [
-        sys.executable,
-        "-m",
-        "pip",
-        "install",
-        "--no-build-isolation",
-        "--no-deps",
-        "--no-cache-dir",
-        f"{pypi_name}=={pypi_version}",
-    ]
-    result = _sp.run(
-        pypi_cmd,
-        stdout = _sp.PIPE,
-        stderr = _sp.STDOUT,
-        text = True,
-    )
+    is_hip = env and env.get("hip_version")
+    if is_hip and not shutil.which("hipcc"):
+        logger.error(
+            "%s requires hipcc for source compilation on ROCm. "
+            "Install the ROCm HIP SDK: https://rocm.docs.amd.com",
+            display_name,
+        )
+        _send_status(
+            event_queue,
+            f"{display_name}: hipcc not found (ROCm HIP SDK required)",
+        )
+        return
+
+    if is_hip:
+        _send_status(
+            event_queue,
+            f"Compiling {display_name} from source for ROCm "
+            "(this may take several minutes)...",
+        )
+    else:
+        _send_status(event_queue, f"Installing {display_name} from PyPI...")
+
+    # Prefer uv for faster dependency resolution when available
+    if shutil.which("uv"):
+        pypi_cmd = [
+            "uv",
+            "pip",
+            "install",
+            "--python",
+            sys.executable,
+            "--no-build-isolation",
+            "--no-deps",
+        ]
+        # Avoid stale cache artifacts from partial HIP source builds
+        if is_hip:
+            pypi_cmd.append("--no-cache")
+        pypi_cmd.append(f"{pypi_name}=={pypi_version}")
+    else:
+        pypi_cmd = [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "--no-build-isolation",
+            "--no-deps",
+            "--no-cache-dir",
+            f"{pypi_name}=={pypi_version}",
+        ]
+
+    # Source compilation on ROCm can take 10-30 minutes; use a generous
+    # timeout. Non-HIP installs preserve the pre-existing "no timeout"
+    # behaviour so unrelated slow installs (e.g. causal-conv1d source
+    # build on Linux aarch64 or unsupported torch/CUDA combinations)
+    # are not aborted at 5 minutes by this PR.
+    _run_kwargs: dict[str, Any] = {
+        "stdout": _sp.PIPE,
+        "stderr": _sp.STDOUT,
+        "text": True,
+    }
+    if is_hip:
+        _run_kwargs["timeout"] = 1800
+
+    try:
+        result = _sp.run(pypi_cmd, **_run_kwargs)
+    except _sp.TimeoutExpired:
+        logger.error(
+            "%s installation timed out after %ds",
+            display_name,
+            _run_kwargs.get("timeout"),
+        )
+        _send_status(
+            event_queue,
+            f"{display_name} installation timed out after "
+            f"{_run_kwargs.get('timeout')}s",
+        )
+        return
+
     if result.returncode != 0:
-        logger.error("Failed to install %s from PyPI:\n%s", display_name, result.stdout)
+        if is_hip:
+            # Surface a clear error for ROCm source build failures
+            error_lines = (result.stdout or "").strip().splitlines()
+            snippet = "\n".join(error_lines[-5:]) if error_lines else "(no output)"
+            logger.error(
+                "Failed to compile %s for ROCm:\n%s",
+                display_name,
+                result.stdout,
+            )
+            _send_status(
+                event_queue,
+                f"Failed to compile {display_name} for ROCm. "
+                "Check that hipcc and ROCm development headers are installed.\n"
+                f"{snippet}",
+            )
+        else:
+            logger.error(
+                "Failed to install %s from PyPI:\n%s",
+                display_name,
+                result.stdout,
+            )
         return
 
-    logger.info("Installed %s from PyPI", display_name)
+    if is_hip:
+        logger.info("Compiled and installed %s from source for ROCm", display_name)
+    else:
+        logger.info("Installed %s from PyPI", display_name)
 
 
 def _ensure_causal_conv1d_fast_path(event_queue: Any, model_name: str) -> None:

studio/backend/main.py

@@ -237,6 +237,7 @@ async def get_system_info():
     import platform
     import psutil
     from utils.hardware import get_device
+    from utils.hardware.hardware import _backend_label
 
     visibility_info = get_backend_visible_gpu_info()
     gpu_info = {
@@ -250,7 +251,10 @@ async def get_system_info():
     return {
         "platform": platform.platform(),
         "python_version": platform.python_version(),
-        "device_backend": get_device().value,
+        # Use the centralized _backend_label helper so the /api/system
+        # endpoint reports "rocm" on AMD hosts instead of "cuda", matching
+        # the /api/hardware and /api/gpu-visibility endpoints.
+        "device_backend": _backend_label(get_device()),
         "cpu_count": psutil.cpu_count(),
         "memory": {
             "total_gb": round(memory.total / 1e9, 2),

studio/backend/utils/hardware/__init__.py

@@ -5,6 +5,7 @@
 Hardware detection and GPU utilities
 """
 
+from . import hardware as _hardware
 from .hardware import (
     DeviceType,
     DEVICE,
@@ -49,6 +50,7 @@
     "DeviceType",
     "DEVICE",
     "CHAT_ONLY",
+    "IS_ROCM",
     "detect_hardware",
     "get_device",
     "is_apple_silicon",
@@ -81,3 +83,11 @@
     "extract_arch_config",
     "estimate_training_vram",
 ]
+
+
+def __getattr__(name: str):
+    """Resolve IS_ROCM at access time so callers always see the live value
+    after detect_hardware() runs (it flips the flag in hardware.py)."""
+    if name == "IS_ROCM":
+        return getattr(_hardware, "IS_ROCM")
+    raise AttributeError(name)