ultralytics/yolov5

On ROCm, PyTorch exposes the HIP backend through the torch.cuda namespace, so torch.cuda.is_available() returns True when HIP is active and generally works without changes. For explicit ROCm awareness, you can additionally check torch.version.hip to distinguish AMD GPU availability from NVIDIA CUDA.

TensorRT is an NVIDIA-only inference optimization library with no ROCm equivalent; on AMD Instinct GPUs the closest alternative is MIGraphX or ONNX Runtime with the ROCm execution provider. This import will fail on ROCm systems and must be replaced or conditionally guarded depending on the target platform.

--- export.py
+++ export.py
@@ -616,7 +616,11 @@
 # NVIDIA TensorRT import — not available on ROCm
-import tensorrt as trt
+try:
+    import tensorrt as trt
+    HAS_TRT = True
+except ImportError:
+    trt = None
+    HAS_TRT = False
+    # On ROCm, consider migraphx or onnxruntime with ROCm EP as alternatives

TensorRT is NVIDIA-specific and has no ROCm equivalent at the same API level; on AMD Instinct GPUs the closest alternative is MIGraphX or ONNX Runtime with the ROCm execution provider. This import will fail on ROCm systems and the surrounding export/inference path must be ported or conditionally guarded.

--- export.py
+++ export.py
@@ -623,1 +623,8 @@
-import tensorrt as trt
+try:
+    import tensorrt as trt
+    _HAS_TENSORRT = True
+except ImportError:
+    trt = None
+    _HAS_TENSORRT = False
+    # Advisory: on ROCm, consider migraphx or onnxruntime with ROCm EP
+    # as a replacement for TensorRT inference optimization.

On ROCm, torch.cuda.is_available() returns True for AMD Instinct GPUs via PyTorch's CUDA-compatibility layer, so the branch logic still executes; however, the resulting tensorflow (GPU) package targets NVIDIA CUDA and will not use ROCm. For AMD GPUs you should prefer tensorflow-cpu or a ROCm-enabled TensorFlow build rather than the CUDA default.

On ROCm, PyTorch's HIP build aliases torch.cuda APIs so torch.cuda.is_available() returns true when a HIP device is present, but relying on the CUDA namespace reduces portability and clarity. Prefer a device-agnostic check or torch.version.hip to make ROCm intent explicit.

TensorRT is an NVIDIA-only inference optimization library with no ROCm equivalent; importing it unconditionally will fail on AMD Instinct systems. This import should be guarded behind a try/except or a runtime backend check so the module remains importable on ROCm. For equivalent functionality on AMD, consider ONNX Runtime with the ROCm EP or MIGraphX.

--- models/common.py
+++ models/common.py
@@ -531,7 +531,11 @@
 
-import tensorrt as trt  # https://developer.nvidia.com/nvidia-tensorrt-download
+try:
+    import tensorrt as trt  # https://developer.nvidia.com/nvidia-tensorrt-download
+except ImportError:
+    trt = None  # Not available on ROCm; consider MIGraphX or ONNX Runtime ROCm EP

Hardcoding "cuda:0" ties the code to CUDA-specific device naming. On ROCm PyTorch builds, "cuda" device strings often still work via the HIP compatibility layer, but for portability and clarity the device should be resolved dynamically (e.g., via torch.device("cuda" if torch.cuda.is_available() else "cpu"), or a configurable device string).

Hardcoding a check for the substring "cuda" in device.type will fail to recognize AMD Instinct GPUs, whose device type is typically "hip" (or "cuda" only when using the CUDA-on-HIP shim). This control-flow branch may be silently skipped on ROCm, leading to wrong device selection or skipped GPU paths.

On ROCm, PyTorch exposes the torch.cuda namespace via HIP compatibility, so torch.cuda.isavailable() and torch.cuda.memoryreserved() function without source changes. No migration action is required, though you could optionally use device-agnostic APIs for long-term portability.

torch.cuda.device_count() is supported on ROCm via PyTorch's CUDA-compatibility shim and will return the number of AMD Instinct GPUs, so no functional change is required. The only advisory change is cosmetic: the assertion message references 'CUDA devices', which could be made vendor-neutral for clarity in a mixed-environment codebase.

torch.cuda.setdevice() is transparently mapped by PyTorch's HIP layer on ROCm, so this call will function on AMD Instinct GPUs without modification. However, for cleaner portability and to avoid relying on the cuda namespace aliasing, consider using LOCALRANK with a device-agnostic pattern or setting HIPVISIBLEDEVICES/ROCRVISIBLEDEVICES before process launch.

PyTorch ROCm builds accept the "cuda" device string via HIP compatibility, so this line may work unchanged. However, for portability across NVIDIA and AMD backends, prefer a runtime-resolved device string so the same code runs on either platform without hardcoding.

torch.cuda.device_count() is supported on ROCm through PyTorch's HIP compatibility layer and will return the number of AMD Instinct GPUs. No code change is strictly required, though the torch.cuda namespace remains CUDA-specific in naming.

torch.cuda.amp.GradScaler generally functions on ROCm because PyTorch maps the cuda namespace to HIP, but it is deprecated in newer PyTorch in favor of the device-agnostic torch.amp API. Migrating to torch.amp.GradScaler('cuda') improves portability and forward-compatibility across CUDA and ROCm backends.

torch.cuda.memoryreserved() and torch.cuda.isavailable() are nominally functional on ROCm via PyTorch's HIP mapping, but hardcoding the CUDA namespace reduces portability across backends. For a device-agnostic memory report, prefer torch.cuda still works on ROCm, but wrap with a backend check or use a utility that abstracts the accelerator.

PyTorch's ROCm backend provides a compatibility layer that maps torch.cuda APIs to the underlying HIP runtime, so this call works natively without requiring code changes. It will correctly trigger the HIP caching allocator to release unused memory. No migration action is needed.

torch.cuda.device_count() is functionally compatible on ROCm because PyTorch maps the torch.cuda namespace to HIP devices, so no code change is required for correctness. The only advisory change is to make the assertion message vendor-neutral, since it currently says 'CUDA devices' which is misleading on AMD Instinct GPUs.

PyTorch's ROCm build exposes the torch.cuda namespace as a HIP compatibility shim, so torch.cuda.set_device works as-is on AMD Instinct GPUs with no functional change required. This is low-risk for migration; the only consideration is that the CUDA_VISIBLE_DEVICES env var (rather than ROCR_VISIBLE_DEVICES) still governs device visibility under this shim.

PyTorch on ROCm retains the "cuda" device-string for source compatibility, so this line will function as-is on AMD Instinct GPUs. However, hardcoding "cuda" obscures portability; making the backend configurable via an environment variable is the recommended advisory change.

On ROCm, torch.cuda.is_available() typically returns True via the CUDA compatibility layer, so this line often works unchanged. For a more explicit/portable migration, you can gate on torch.version.hip or use a device-agnostic availability check to avoid implying NVIDIA-only CUDA.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

The literal device string "cuda" resolves to the active AMD GPU on ROCm PyTorch. .to("cuda") / device="cuda" need no edits.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.

Calls under torch.cuda.* are aliased by ROCm builds of PyTorch. The same code runs on AMD Instinct GPUs unchanged — torch.cuda.is_available(), streams, events and AMP all map onto HIP.