⚡ electrical engineering

WaveNet-Style Guitar Amplifier Model Pruning for Real-Time iOS Deployment

This paper presents a real-time iOS implementation of a pruned WaveNet-style guitar amplifier model that achieves 90% weight reduction through iterative magnitude pruning and a custom sparse C++ engine, enabling high-fidelity, low-latency emulation of physical pedals on CPU-only iPhones with no perceptible quality loss.

Original authors: Ryota Sato, Eli Silverstein

Published 2026-07-14

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Ryota Sato, Eli Silverstein

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a guitar amplifier that sounds so real, it feels like you're holding a tube amp from the 1960s. Now, imagine trying to run that exact sound inside a smartphone. Usually, that's like trying to fit a full-sized orchestra into a shoebox; the computer inside the phone just can't handle the math, and the sound would lag or stutter.

But in this paper, Ryota Sato and Eli Silverstein from Stanford University found a clever trick to shrink that orchestra down to a soloist without losing the music. They took a super-smart computer program called a "WaveNet" that learns to copy guitar amps and pedals, and they made it incredibly efficient so it can run in real-time on an iPhone using only the phone's main brain (the CPU), without needing special graphics chips.

The Magic of the "Pruning" Scissors
Think of the neural network (the computer program) like a massive, tangled ball of yarn with thousands of threads. Most of these threads are actually doing very little work. The researchers used a technique called "iterative magnitude pruning," which is like a very careful pair of scissors. Instead of cutting the yarn once and hoping for the best, they snipped away the useless threads bit by bit while the program was still learning.

They managed to cut away 90% of the connections (the "weights") in the network. To put that in perspective, if the original program had 21,913 total parts, they removed 19,074 of the prunable ones, leaving just a tiny skeleton of the original.

Why One Cut Didn't Work
The paper explicitly warns against a lazy approach called "one-shot pruning." Imagine trying to cut 90% of the yarn off the ball in one giant, messy swipe. The authors found that this method failed completely; the sound quality collapsed, and the program couldn't track the guitar notes anymore. It was only by cutting slowly and letting the network adapt that they kept the sound perfect.

The Result: A Phone That Sounds Like a Pedal
With this "sparse" (mostly empty) network, the iPhone can now play guitar audio in real-time with a delay of only about 5.3 milliseconds (using a block size of 256 samples at 48 kHz).

The team tested this on four different guitar sounds: a Vox AC15, a Fender Deluxe Reverb, a Fender Tweed-style amp, and a Dunlop Fuzz Face pedal. The results were impressive:

The error rate was incredibly low, staying below 3.4 × 10⁻⁴ (measured by a metric called Error-to-Signal Ratio, or ESR).
To human ears, there was no noticeable drop in quality compared to the original, uncut model.
The sound matched the original training data so closely that any difference was smaller than the tiny rounding errors you get when converting numbers (specifically, within int16 quantization error).

What It Can't Do (Yet)
The paper is honest about what this model doesn't do. Because the computer model is "deterministic" (it follows strict rules), it cannot recreate the random, chaotic background noise or "hum" that real, old-school amplifiers make. For example, when playing a high-gain Fuzz Face pedal, the real hardware has a bit of static and buzz that the phone model leaves out. The paper notes this is the main limitation, but it's not a dealbreaker for the sound itself.

The Real-World Test
The researchers didn't just run simulations; they built a working app. They measured how fast the phone could process the sound and found that the full, uncut model was impossible to run (it was "intractable"). However, the 90% pruned version ran comfortably, with a "Real-Time Factor" (RTF) of about 0.6. This means the phone finished processing the audio in 60% of the time it took to play it, leaving plenty of room to spare.

At their demonstration, visitors will be able to plug a guitar into an iPhone, switch between different modeled amps, and even compare the phone's version of a Fuzz Face pedal directly against the real, physical pedal using a Line 6 HX Stomp. The goal is to show that you don't need a giant desktop computer or expensive hardware to get professional guitar tones anymore; a heavily pruned, smartly coded app on your pocket computer can do the job just as well.

Technical Summary: WaveNet-Style Guitar Amplifier Model Pruning for Real-Time iOS Deployment

Problem Statement
WaveNet-style convolutional networks have demonstrated high fidelity in emulating tube amplifiers and distortion pedals, yet their computational intensity has historically restricted deployment to desktop machines or dedicated DSP hardware. While iterative magnitude pruning has been successfully applied to LSTM-based neural amplifier models to improve efficiency, systematic pruning of WaveNet architectures remains largely unexplored. Furthermore, there is a lack of sparsity-aware inference engines capable of running these models on portable consumer devices, such as the iPhone, particularly on CPU-only implementations where dense models are computationally intractable.

Methodology
The authors propose a pipeline comprising model training, aggressive iterative pruning, and a custom sparse inference engine for iOS.

Architecture and Training: The system utilizes a causal, feedforward WaveNet variant with stacked dilated convolutional residual blocks. The network maps raw guitar input waveforms to distorted outputs. Unlike the original architecture, the authors replaced gated tanh activations with standard tanh nonlinearities to reduce computational overhead. The model was trained for 1,500 epochs using Mean Squared Error (MSE) on pre-emphasized signals (via a first-order IIR high-pass filter), though Error-to-Signal Ratio (ESR) was used for evaluation.
Pruning Strategy: To achieve sparsity, the authors employed iterative local magnitude pruning. Unlike "one-shot" pruning (removing weights post-training), this method updates the pruning mask every mini-batch according to a sparsity schedule. The schedule ramps sparsity from 0% to a target of 90% between specific epochs using an exponential schedule. This approach allows the network to adapt to sparsity during training, preserving accuracy where one-shot pruning fails.
Sparse Inference Engine: A custom C++ engine was developed specifically for iOS to leverage the sparsity. Unlike general-purpose libraries (e.g., RTNeural) that operate on dense kernels, this engine stores and iterates only over non-zero weights in a compact, cache-friendly layout. This design ensures that unstructured sparsity translates directly into compute savings. The engine processes audio in fixed-size blocks (default 256 samples at 48 kHz) entirely on the CPU, avoiding the dispatch latency associated with GPU or Neural Engine interfaces for small workloads.

Key Contributions

High-Sparsity Pruning of WaveNet: The paper demonstrates that WaveNet-style neural amplifiers can be pruned to 90% sparsity with no perceptible loss in audio quality, a regime where naive one-shot pruning causes model collapse.
CPU-Only Real-Time iOS Deployment: The authors successfully deployed the heavily pruned model on an iPhone using a CPU-only implementation. The dense model is intractable on this hardware, whereas the 90% pruned model operates with a comfortable real-time margin.
Custom Sparse Engine: The development of a specialized C++ inference engine that bypasses dense-kernel libraries to realize the computational benefits of sparsity on mobile hardware.

Results

Audio Quality: At 90% sparsity, the model reproduced four distinct guitar distortion sources (Vox AC15, Fender Deluxe Reverb, Fender Tweed-style, and Dunlop Fuzz Face) with ESR values below $3.4 \times 10^{-4}$ . Informal listening tests revealed no audible degradation. The output matched the trained Python reference within int16 quantization error.
Performance: On an iPhone 16 Pro with a 256-sample block size, the 90% pruned model achieved a Real-Time Factor (RTF) of approximately 0.6, well below the real-time threshold of 1.0. In contrast, the dense model was intractable. The 90% sparsity point was identified as a conservative operating point that provides a safety margin for real-time operation.
Limitations: As a deterministic model, the system cannot reproduce input-uncorrelated noise and hum, which is most noticeable in high-gain scenarios like the Fuzz Face emulation.

Significance
The paper establishes that heavy iterative magnitude pruning, when paired with a sparse-aware inference engine, enables the real-time execution of computationally expensive WaveNet-style neural guitar amplifiers on CPU-only mobile devices. This work bridges the gap between high-fidelity black-box modeling and portable consumer hardware, demonstrating that such models can run on iPhones with no perceptible loss in quality, provided the inference engine is optimized to exploit the resulting sparsity.

Technical Summary: WaveNet-Style Guitar Amplifier Model Pruning for Real-Time iOS Deployment

More like this