Beirit Harvey

Learn how to use PyTorch & Hugging Face with ROCm 7 on AMD cloud instances. Our guide shows you how to build, fine-tune, and deploy open-source AI models on TensorWave.

Open Source AI Frameworks on AMD: How to Use PyTorch and Hugging Face with ROCm 7

The AI landscape is being reshaped by the powerful combination of open-source software and specialized hardware. For years, developing complex models was often constrained by proprietary software and a limited hardware ecosystem. Today, that paradigm is shifting. The rise of community-driven tools like PyTorch and Hugging Face, combined with the computational power of AMD cloud instances, is democratizing high-performance AI.

TensorWave, built on cutting-edge AMD hardware, offers an environment

The AI landscape is being reshaped by the powerful combination of open-source software and specialized hardware. For years, developing complex models was often constrained by proprietary software and a limited hardware ecosystem. Today, that paradigm is shifting. The rise of community-driven tools like PyTorch and Hugging Face, combined with the computational power of AMD cloud instances, is democratizing high-performance AI.

TensorWave, built on cutting-edge AMD hardware, offers an environment where this combination truly shines. This guide will walk you through leveraging the core pillars of modern, open-source AI frameworks—specifically Hugging Face and PyTorch, powered by the latest ROCm 7 software stack—to build, fine-tune, and deploy models on TensorWave's infrastructure.


Why Open Source AI Frameworks, AMD, and TensorWave?

Before we dive into the technical details, it's crucial to understand the "why" behind this stack.

 * Open Source AI Frameworks (PyTorch & Hugging Face): PyTorch remains the standard for AI research due to its intuitive interface. Hugging Face's transformers library builds on this, providing a vast repository of pre-trained models that drastically reduce time-to-market. This open ecosystem fosters innovation and collaboration.
 * AMD Instinct™ Accelerators: AMD's GPUs, like the MI355X, are engineered for high-performance AI, offering exceptional memory bandwidth and compute power critical for large models.
 * ROCm 7 (Radeon Open Compute platform): ROCm is AMD's open-source software stack for GPU computing. ROCm 7 represents a significant leap forward with enhanced stability, broader model support, and improved performance, making it the essential bridge that allows frameworks like PyTorch to run seamlessly on AMD hardware.
 * TensorWave's Cloud Platform: TensorWave integrates these components into a cohesive, high-performance environment. It provides enterprise access to AMD Instinct accelerators, pre-configured with the ROCm 7 stack, eliminating the friction of setup so you can focus on building models.


The Foundation: Understanding ROCm 7 on TensorWave

When you provision an AMD-powered instance on TensorWave, the ROCm 7 platform is already installed and optimized. Key components include:

 * HIP (Heterogeneous-compute Interface for Portability): A C++ runtime API that allows developers to create portable applications that can run on both AMD and NVIDIA GPUs.
 * rocBLAS, rocFFT, MIOpen: GPU-accelerated libraries for fundamental operations like linear algebra and deep learning primitives.
 * ROCm-aware PyTorch: A pre-compiled build of PyTorch that uses the ROCm 7 backend, automatically dispatching operations to the AMD GPU.

You can verify your TensorWave instance is correctly recognizing the AMD GPU(s) using the amd-smi command in the terminal.

Step 1: Setting Up Your Development Environment on TensorWave

After accessing your TensorWave instance, work within a Python virtual environment to manage dependencies. AMD notes within their documentation that it’s recommended to use a docker image with PyTorch pre-installed. Another way to do so is to use a wheels package or the PyTorch upstream Dockerfile.

Step 2: Validating Your ROCm 7 & PyTorch Installation

Your PyTorch installation from AMD's official sources is ready to use. If you used a pre-built Docker image or an official ROCm package, you can skip validation and start coding right away.

To manually run unit tests to validate your PyTorch installation fully, make sure to follow these steps:

 1. To verify your PyTorch installation, import it in Python:

Please note: Run this command from your project's directory.

python3 -c 'import torch' 2> /dev/null && echo 'Success' || echo 'Failure

 2. Check that PyTorch can successfully detect and access your AMD GPU.

python3 -c 'import torch; print(torch.cuda.is_available())

 3. Fully validate your PyTorch installation by running its unit tests.

Please note, AMD's documentation mentions you have to “run the following command from the PyTorch home directory.”

PYTORCH_TEST_WITH_ROCM=1 python3 test/run_test.py --verbose \
--include test_nn test_torch test_cuda test_ops \
test_unary_ufuncs test_binary_ufuncs test_autograd

Step 3: Train a Custom Model with PyTorch and ROCm 7

The PyTorch for ROCm training Docker image delivers a ready-to-use, optimized environment for fine-tuning and pre-training models on AMD Instinct MI325X and MI355X GPUs. It comes pre-loaded with all the essential software to accelerate your training workloads. For a complete list of components and versions, please refer to the official AMD documentation. Furthermore, you’ll also need to clarify which models are supported and pre-optimized by these specific AMD GPUs and others. 

Step 4: Supercharging Development with Hugging Face Transformers

This is where the Hugging Face ecosystem shines, providing the standardized models and datasets needed for consistent and meaningful benchmarks.

Once the setup is complete, you can begin benchmarking your training performance using one of these methods:

A. MAD-Integrated Benchmarking: Utilize the built-in benchmarking tools within the Machine Learning Automation & Deployment (MAD) framework for a streamlined, automated testing process.

To start this process you should be aware that for both MAD and Standalone benchmarking, the following command is configured for the Llama 4 Scout 17B-16E model. To use a different model, please see the list of Supported Models on AMD’s documentation page.

 1. Get started by cloning the ROCm Model Automation and Dashboarding (ROCm/MAD) repository to your local machine and installing its required packages.

git clone https://github.com/ROCm/MAD
cd MAD
pip install -r requirements.txt

 2. This command runs a performance benchmark on the Llama 4 Scout 17B-16E model using one node with the BF16 data type.

export MAD_SECRETS_HFTOKEN="your personal Hugging Face token to access gated models"
madengine run \
    --tags pyt_train_llama-4-scout-17b-16e \
    --keep-model-dir \
    --live-output \
    --timeout 28800

MAD will then launch a Docker container with the name:

container_ci-pyt_train_llama-4-scout-17b-16e and the model's latency and throughput reports are saved to ~/MAD/perf.csv.

B. Standalone Benchmarking: Run benchmarks directly and independently for granular control and customized performance analysis.

First, you will need to download the Docker image and required packages by following the steps below. 

 1. The following command can be used to pull the Docker image from Docker Hub for the MI355X and MI350X AMD GPU.

docker pull rocm/pytorch-training:v25.9_gfx950

 2. Now you can launch the Docker container. 

docker run -it \
    --device /dev/dri \
    --device /dev/kfd \
    --network host \
    --ipc host \
    --group-add video \
    --cap-add SYS_PTRACE \
    --security-opt seccomp=unconfined \
    --privileged \
    -v $HOME:$HOME \
    -v $HOME/.ssh:/root/.ssh \
    --shm-size 64G \
    --name training_env \
    rocm/pytorch-training:v25.9_gfx950

If you exit the training_env and need to return to it, use these commands:  

docker start training_env
docker exec -it training_env bash

 3. Once inside the Docker container, clone the ROCm/MAD repository and navigate to the benchmark scripts directory at  /workspace/MAD/scripts/pytorch_train.

git clone https://github.com/ROCm/MAD
cd MAD/scripts/pytorch_train

Once you’ve downloaded the Docker image and required packages, you’ll need to prepare your training datasets and dependencies.

 1. To run these benchmarks, you'll need to download models and datasets from Hugging Face. Ensure you set your  HF_TOKEN for successful access to gated repositories.

export HF_TOKEN=$your_personal_hugging_face_access_token

 2. Execute the setup script to install the required libraries and datasets for benchmarking.

./pytorch_benchmark_setup.sh

When executed, pytorch_benchmark_setup.sh  automatically downloads the following datasets from Hugging Face:

https://huggingface.co/datasets/frank-chieng/chinese_architecture_siheyuan

Now it’s time to start fine-tuning, you can use the command below, but make sure to choose the right options. These options can be referenced in AMD’s documentation. 

./pytorch_benchmark_report.sh -t $training_mode \
    -m Llama-4-17B_16E \
    -p $datatype \
    -s $sequence_length

Best Practices and Troubleshooting for ROCm 7

 * Memory Management: Start with small batch sizes and increase gradually. Monitor usage with amd-smi.
 * Version Control: Document versions of ROCm, PyTorch, and other libraries. Consider Docker for reproducibility.
 * Performance Profiling: Use ROCm's profiler (rocprof) to identify bottlenecks.
 * Mixed Precision Training: Utilize torch.cuda.amp with ROCm’s HIP backend for automatic mixed precision (AMP) to boost training speed and reduce memory usage on supported AMD GPUs.

Unleashing Open Source AI on High-Performance Hardware

The convergence of PyTorch and Hugging Face with the AMD infrastructure provided by TensorWave represents a formidable force in the AI landscape. This stack offers a powerful, open-standard alternative.

By following this guide, you've learned how to validate your ROCm 7 setup, build custom models with PyTorch, and leverage Hugging Face—all accelerated by AMD's software stack. This combination provides the computational muscle for demanding AI tasks without vendor lock-in.


About TensorWave

TensorWave is the AI neocloud purpose-built for performance. Powered exclusively by AMD Instinct™ Series GPUs, we deliver high-bandwidth, memory-optimized infrastructure that scales with your most demanding models—training or inference.

Ready to get started? Connect with a Sales Engineer.

AMD Instinct™ MI355X GPUs Now Available

Open Source AI Frameworks on AMD: How to Use PyTorch and Hugging Face with ROCm 7

Subscribe to our Blog

Stay ahead of the curve with the latest in AI, AMD accelerators, and all things TensorWave.

Product

Resources

Company

© 2025 TensorWave Inc. - All rights reserved.