Voice Cloning on AMD Strix Halo: Running Chatterbox TTS with Native GPU Acceleration

TL;DR: Chatterbox TTS (Resemble AI’s open-source voice cloning model) runs natively on Strix Halo’s Radeon 8060S iGPU using TheROCK nightly PyTorch builds. No CPU fallback. No cloud. ~10 seconds per clip from a 10-second voice sample. Here’s every step and every gotcha.

Quick Start (copy/paste)

Prereqs: ROCm installed (e.g. /opt/rocm) + python3.12 available.

# 0) Create project and venv
mkdir -p ~/projects/chatterbox-tts
cd ~/projects/chatterbox-tts

uv venv --python 3.12 venv
source venv/bin/activate

# 1) TheROCK nightlies for Strix Halo (gfx1151)
pip install torch torchvision torchaudio \
  --index-url https://rocm.nightlies.amd.com/v2/gfx1151/

# 2) Chatterbox + deps (relaxed versions)
pip install chatterbox-tts --no-deps

pip install numpy scipy soundfile tokenizers \
  conformer einops encodec s3tokenizer \
  resemble-perth pyyaml safetensors \
  huggingface_hub transformers

Then run it:

python tts.py --text "The quick brown fox jumped over the lazy dog." \
  --reference my-voice-sample.mp3 \
  --out cloned-output.wav \
  --exaggeration 0.5

First run downloads model weights (~2 GB from HuggingFace). If anything breaks, the detailed walkthrough below covers every gotcha.

Why This Matters

Chatterbox is one of the first open-source voice cloning models I’ve used that can compete with ElevenLabs in similarity — locally, from a short reference clip. It clones a voice from a 10–20 second audio sample and generates new speech in that voice, on your own hardware.

The problem: Chatterbox requires PyTorch with GPU acceleration. The standard PyTorch ROCm wheels (built for ROCm 6.4) don’t include kernels for gfx1151 (Strix Halo’s GPU architecture). You’ll get HIP error: invalid device function and fall back to CPU, where generation takes minutes instead of seconds.

The solution: TheROCK nightly builds from AMD, which compile PyTorch with native gfx1151 support.

Hardware

• CPU: AMD Ryzen AI MAX+ 395
• GPU: Radeon 8060S (integrated, gfx1151)
• RAM: 128 GB unified memory (64/64 VRAM/RAM split)
• OS: Ubuntu 24.04, Linux 6.18.1
• ROCm: 7.1.0 (system install at /opt/rocm)

The unified memory architecture is a huge advantage here — the 0.5B parameter model loads into VRAM that’s shared with system RAM. No discrete GPU required.

Step 1: Create a Python 3.12 Virtual Environment

Python 3.13 breaks several dependencies (audioop removed, pkgutil.ImpImporter removed, setuptools issues). Stick with 3.12.

mkdir -p ~/projects/chatterbox-tts
cd ~/projects/chatterbox-tts

# Using uv (fast, recommended)
uv venv --python 3.12 venv
source venv/bin/activate

Step 2: Install TheROCK Nightly PyTorch

This is the critical step. Do NOT use the standard pip install torch — those wheels don't have gfx1151 kernels.

# TheROCK nightlies with native gfx1151 support
pip install torch torchvision torchaudio \
  --index-url https://rocm.nightlies.amd.com/v2/gfx1151/

# Verify
python -c "import torch; print(torch.__version__); print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0))"

You should see something like:

2.11.0a0+rocm7.11.0a
True
Radeon 8060S Graphics

Note: On ROCm builds, PyTorch still exposes AMD GPUs through the torch.cuda namespace. So torch.cuda.is_available() can return True and torch.cuda.get_device_name(0) will show your Radeon device even though you're not using NVIDIA CUDA.

If torch.cuda.is_available() returns False, your ROCm install is broken. Check /opt/rocm/bin/rocminfo for your GPU.

Step 3: Install Chatterbox (with relaxed dependencies)

Chatterbox pins torch==2.6.0 and numpy<1.26.0 in its requirements, which conflicts with both Python 3.12 and the TheROCK nightly torch. Install with --no-deps and handle dependencies manually:

pip install chatterbox-tts --no-deps

# Install the actual dependencies with relaxed versions
pip install numpy scipy soundfile tokenizers \
  conformer einops encodec s3tokenizer \
  resemble-perth pyyaml safetensors \
  huggingface_hub transformers

Step 4: Patch the Watermarker

Chatterbox includes an audio watermarking library (resemble-perth) that uses a binary module. On TheROCK torch builds, the binary is incompatible and PerthImplicitWatermarker() returns None.

Find your installed chatterbox package:

CHATTERBOX_PATH=$(python -c "import chatterbox; print(chatterbox.__path__[0])")

Edit $CHATTERBOX_PATH/tts.py. Find the watermarker initialization (around line 148):

# Original:
self.watermarker = perth.PerthImplicitWatermarker()

# Replace with:
try:
    self.watermarker = perth.PerthImplicitWatermarker()
    if self.watermarker is None:
        raise TypeError("PerthImplicitWatermarker returned None")
except (TypeError, Exception):
    self.watermarker = perth.DummyWatermarker()

This falls back to a no-op watermarker. For personal/local use this is fine — the watermark is inaudible anyway and only matters if you’re distributing generated audio commercially.

Step 5: Set Up Environment Variables

Strix Halo needs specific ROCm environment variables. Create a launch script:

#!/bin/bash
# run-tts.sh — Strix Halo GPU config for Chatterbox TTS

# Clear any conflicting env from other ROCm tools
unset PYTORCH_TUNABLEOP_ENABLED PYTORCH_TUNABLEOP_TUNING
unset PYTORCH_HIP_ALLOC_CONF PYTORCH_ALLOC_CONF
unset HSA_FORCE_FINE_GRAIN_PCIE

# ROCm paths
export HIP_VISIBLE_DEVICES=0
export ROCM_PATH=/opt/rocm
export PATH=$PATH:/opt/rocm/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/rocm/lib

# Strix Halo specific
export HSA_OVERRIDE_GFX_VERSION=11.5.1
export HSA_FORCE_FINE_GRAIN_PCIE=1

# Memory allocator — prevent fragmentation on unified memory
export PYTORCH_CUDA_ALLOC_CONF="garbage_collection_threshold:0.8,max_split_size_mb:512,expandable_segments:True"
export PYTORCH_HIP_ALLOC_CONF="garbage_collection_threshold:0.8,max_split_size_mb:512,expandable_segments:True"

# MIOpen — skip slow autotuning
export MIOPEN_FIND_MODE=FAST
export MIOPEN_DEBUG_CONV_IMPLICIT_GEMM=0
export MIOPEN_DISABLE_CACHE=1
export MIOPEN_USER_DB_PATH=/tmp/miopen_cache

# PyTorch ROCm architecture
export PYTORCH_ROCM_ARCH=gfx1151
export TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1
export FLASH_ATTENTION_TRITON_AMD_ENABLE="TRUE"

source ~/projects/chatterbox-tts/venv/bin/activate

python tts.py "$@"

Why These Variables Matter

• **HSA_OVERRIDE_GFX_VERSION=11.5.1**: Tells the HIP runtime to treat the GPU as gfx1151. Even though TheROCK nightlies have native kernels, this override ensures compatibility with any libraries that haven't been updated.
• **HSA_FORCE_FINE_GRAIN_PCIE=1**: Enables fine-grained memory access. Critical for Strix Halo's unified memory architecture where GPU and CPU share the same physical RAM.
• **MIOPEN_FIND_MODE=FAST**: Skips exhaustive kernel autotuning. First-run MIOpen tuning can take 30+ seconds per convolution shape. FAST mode uses heuristics instead.
• **PYTORCH_ROCM_ARCH=gfx1151**: Ensures any JIT-compiled kernels target the correct architecture.
• **TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1**: Enables experimental AOTriton kernels that give significant speedups on RDNA 4 architecture.

Step 6: Write the TTS Script

#!/usr/bin/env python3
"""Chatterbox TTS on Strix Halo — voice cloning from a reference sample."""

import argparse
import time
from pathlib import Path

import torch
import soundfile as sf

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--text", required=True, help="Text to speak")
    parser.add_argument("--reference", required=True,
                        help="Path to voice reference audio (10-20s MP3/WAV)")
    parser.add_argument("--out", default="output.wav", help="Output WAV path")
    parser.add_argument("--exaggeration", type=float, default=0.5,
                        help="Voice expressiveness 0.0-1.0 (0.3=flat, 0.5=normal, 0.7=expressive)")
    parser.add_argument("--temperature", type=float, default=0.8)
    parser.add_argument("--cfg-weight", type=float, default=0.5)
    parser.add_argument("--cpu", action="store_true", help="Force CPU mode")
    args = parser.parse_args()

    ref = Path(args.reference)
    if not ref.exists():
        raise FileNotFoundError(f"Reference audio not found: {ref}")

    device = "cpu" if args.cpu else ("cuda" if torch.cuda.is_available() else "cpu")

    print(f"Device: {device}")
    if device == "cuda":
        print(f"GPU: {torch.cuda.get_device_name(0)}")

    # Load model
    t0 = time.time()
    from chatterbox.tts import ChatterboxTTS
    model = ChatterboxTTS.from_pretrained(device=device)
    print(f"Model loaded in {time.time() - t0:.1f}s")

    # Generate
    t0 = time.time()
    wav = model.generate(
        text=args.text,
        audio_prompt_path=str(ref),
        exaggeration=args.exaggeration,
        temperature=args.temperature,
        cfg_weight=args.cfg_weight,
    )
    print(f"Generated in {time.time() - t0:.1f}s")

    # Save
    wav_np = wav.squeeze(0).cpu().numpy()
    sf.write(args.out, wav_np, model.sr)
    duration = wav_np.shape[0] / model.sr
    print(f"Saved {args.out} ({duration:.1f}s audio)")

if __name__ == "__main__":
    main()

Step 7: Clone a Voice

Record or obtain a 10–20 second audio sample of the voice you want to clone. Longer isn’t necessarily better — Chatterbox works best with clean, single-speaker audio.

bash run-tts.sh --text "The quick brown fox jumped over the lazy dog." \
  --reference my-voice-sample.mp3 \
  --out cloned-output.wav \
  --exaggeration 0.5

First run downloads the model weights (~2 GB from HuggingFace). Subsequent runs load from cache in ~8 seconds.

Exaggeration Guide

The exaggeration parameter controls how expressive the generated voice is:

ValueStyleUse Case0.2–0.3Flat, authoritativeNarration, commands0.4–0.5Natural, balancedGeneral speech0.6–0.7Warm, expressiveConversational, intimate0.8–0.9Highly emotionalDramatic readings

Performance

On Strix Halo (Radeon 8060S, 64 GB VRAM allocation):

MetricGPU (gfx1151)CPUModel load~8s~8sGeneration (short phrase)~10s~90sGeneration (paragraph)~25s~5min

GPU is roughly 9x faster than CPU for generation. The model load time is similar because it’s dominated by disk I/O and weight deserialization.

Gotchas

1. Don’t use PyTorch ROCm 6.4 wheels. They don’t include gfx1151 kernels. You’ll get HIP error: invalid device function on the first CUDA operation. TheROCK nightlies are the fix.

2. Don’t use HSA_OVERRIDE_GFX_VERSION=11.0.0. This is a common suggestion for Strix Halo but it maps to the wrong architecture. Use 11.5.1.

3. torchaudio.save() requires torchcodec on torch 2.9+. Building torchcodec from source on TheROCK is painful. Use soundfile instead — it's a direct NumPy-to-WAV writer with no torch dependencies.

4. Chatterbox pins old dependencies. torch==2.6.0 and numpy<1.26.0 in its requirements are incompatible with Python 3.12 and TheROCK. Install with --no-deps and manage dependencies yourself.

5. Clear MIOpen cache between torch upgrades. Stale MIOpen kernel caches cause silent performance degradation. rm -rf /tmp/miopen_cache ~/.config/miopen/ when you update torch.

6. GPU_MAX_ALLOC_PERCENT is deprecated. Old ROCm guides tell you to set this. On torch 2.9+ it causes Unknown allocator backend errors. Use PYTORCH_HIP_ALLOC_CONF instead.

What’s Next

Chatterbox is a single-speaker cloning model — one reference voice, one output voice. For multi-speaker or real-time streaming TTS on Strix Halo, look at:

• Orpheus TTS (via Ollama): 3B params, 8 preset voices, emotion tags. Smaller and faster but no voice cloning.
• Fish Speech: Multi-speaker, low-latency. ROCm support is experimental.
• Piper: Lightweight, fast, no GPU needed. Good for bulk synthesis but no cloning.

The Strix Halo’s 128 GB unified memory is absurdly overpowered for TTS — the entire model fits with room for ten more. Where this hardware shines is running TTS alongside other models (LLMs, image generation, vision) simultaneously without model swapping. That’s the real use case.

Tested on AMD Ryzen AI MAX+ 395, Radeon 8060S, Ubuntu 24.04, ROCm 7.1.0, TheROCK nightly PyTorch 2.11.0a0+rocm7.11.0a. March 2026.