Teaching the Radio to Distort Its Own Signal So the Amplifier Cannot

There is a quiet revolution in how a clean signal gets made, and it runs backward from intuition. For decades the way to keep a power amplifier from smearing the spectrum was to feed it a faithful signal and beg it to behave, backing the drive off until the device stayed in its well-mannered linear zone. The modern software-defined radio does something stranger and far more effective. It deliberately feeds the amplifier a distorted signal, twisted into exactly the wrong shape, so that the amplifier's own distortion straightens it back out. The two distortions cancel, and what emerges is clean even though the amplifier was driven hard into its nonlinear region. The trick is called digital predistortion, and the word that makes it powerful is adaptive, because the amplifier is a moving target and the correction has to chase it in real time.

The appeal is the same efficiency prize that drives every linearization scheme, but digital predistortion claims it with a flexibility the analog methods cannot match. Because the predistortion happens in the digital baseband, before any signal becomes analog, it is computed rather than wired, and what is computed can be changed. As the amplifier warms, ages, shifts channels, or sees a different signal level, the correction recomputes itself to match. The radio learns the amplifier's current personality and applies the precise inverse, over and over, thousands of times a second.

The inverse function that cancels the curve

The core idea is an inversion. A power amplifier has a transfer characteristic that bends as it approaches saturation, compressing the output so that large inputs are amplified less than small ones. Plot output amplitude against input amplitude and the curve sags below the straight line it should follow. Digital predistortion places a second block ahead of the amplifier with the opposite curvature, an expanding characteristic that boosts large inputs more than small ones. The predistorter's expansion and the amplifier's compression are designed to be mathematical inverses, so their cascade is linear:

PA( DPD( x ) ) = G * x

where x is the desired signal, DPD is the predistorter's function, PA is the amplifier's function, and G is a constant gain. When the predistorter's curve is exactly the inverse of the amplifier's curve, the bends cancel and the output is a clean, scaled copy of the input. The amplifier still distorts internally, just as hard as ever, but it distorts a signal that was pre-twisted to come out straight.

The distortion that matters is two-sided. Amplitude affects amplitude, called AM-to-AM distortion, the compression of the gain curve. But amplitude also affects phase, called AM-to-PM distortion, because the amplifier's phase shift changes with drive level near saturation. A complete predistorter must invert both, applying an amplitude expansion and a compensating phase rotation that together undo the amplifier's amplitude and phase errors at every signal level.

Why the amplifier has memory and why that complicates everything

A simple inverse curve would suffice if the amplifier responded only to the instantaneous input. Real amplifiers do not. Their output depends not only on the present input but on recent past inputs, an effect called memory, arising from thermal time constants, bias network response, and trapping effects in the device. The compression at this instant depends slightly on what the signal was doing a moment ago. A memoryless inverse curve cannot correct a system with memory, because the right correction now depends on history.

The standard answer is the memory polynomial, a model that captures both the nonlinearity and the memory in one expression. The predistorter output depends on the current and delayed inputs, each raised to various powers:

y(n) = sum over k, sum over m of [ a_km x(n-m) |x(n-m)|^(k-1) ]

where x(n-m) is the input delayed by m samples, the magnitude raised to the power k-1 captures the nonlinearity of order k, and the coefficients a_km are the knobs the radio tunes. The delay terms, indexed by m, give the model memory; the power terms, indexed by k, give it nonlinearity. A typical implementation might use nonlinear orders up to the seventh and memory depths of a handful of samples, yielding a few dozen coefficients that together describe the inverse the amplifier needs.

The learning loop that keeps the inverse correct

The adaptive part is where the software-defined radio earns its keep. The coefficients of the memory polynomial are not fixed at the factory, because the amplifier's behavior drifts. They are found and continuously updated by a learning loop that watches the amplifier's actual output. The dominant architecture is called indirect learning. A copy of the predistorter, called the training block, is fed the amplifier's output scaled down, and its job is to learn the function that maps the amplifier output back to the amplifier input. That function is precisely the inverse the amplifier needs, so once the training block has learned it, its coefficients are copied into the actual predistorter ahead of the amplifier.

The coefficients are solved by least squares. The loop collects samples of the amplifier input and output, forms the memory-polynomial basis from them, and finds the coefficient vector that minimizes the squared error between the desired linear output and the actual output:

minimize over a of || y_desired - X * a ||^2

where X is the matrix of memory-polynomial terms built from the captured samples and a is the coefficient vector. The solution is the classic least-squares estimate, recomputed as new samples arrive so the coefficients track the amplifier as it changes. When the amplifier warms and its curve shifts, the next batch of samples reflects the new behavior, the least-squares solution moves, and the predistorter updates to match without any human intervention or recalibration.

A numerical look at the spectral cleanup

Put numbers to what the loop achieves. The measure of out-of-band distortion is the adjacent channel power ratio, the power leaking into the neighboring channel relative to the main channel, and spectral regrowth is the rise of that leakage when the amplifier compresses. A real software-defined radio implementation of memory-polynomial predistortion with indirect learning reported spectral regrowth suppression of 15 to 20 dB, meaning the distortion power spilling into adjacent channels dropped by that factor once the predistorter engaged.

Translate the gain into operating margin. Suppose an amplifier without correction must run 6 dB backed off from saturation to meet an adjacent-channel specification, sacrificing efficiency to stay clean. The efficiency of a backed-off class B stage scales roughly as

eta(b) = eta_max * 10^(-b/20)

so 6 dB of backoff multiplies efficiency by

10^(-6/20) = 0.50

cutting it in half. With predistortion delivering 15 dB of distortion suppression, the amplifier can run far closer to saturation, perhaps backing off only 2 dB while still meeting the same specification, because the predistorter cleans up what the reduced backoff would otherwise spill. The efficiency at 2 dB backoff is

10^(-2/20) = 0.79

so the efficiency climbs from 50 percent of peak to 79 percent of peak, a gain of more than half again, purely from letting the predistorter handle the linearity that backoff used to provide. On a transmitter running tens or hundreds of watts, that efficiency jump is the difference between a manageable thermal design and a punishing one.

Choosing the model order without drowning in coefficients

A practical question dominates any real build: how many terms does the memory polynomial need? Too few and the inverse is too crude to cancel the distortion; too many and the least-squares solution becomes ill-conditioned, fitting noise instead of the amplifier and demanding processing the radio cannot spare. The coefficient count is the product of the nonlinear order K and the memory depth M:

N_coeff = K * M

so a model with nonlinear order K of 7 and memory depth M of 4 carries

N_coeff = 7 * 4 = 28 coefficients

Each coefficient is complex, doubling the real numbers to solve for, and the least-squares problem grows with the square of that count, so the cost climbs steeply. The discipline is to add only the orders the amplifier actually exhibits. A measurement of the amplifier's distortion spectrum reveals which odd-order products dominate, since a typical amplifier shows strong third and fifth order and weaker seventh, with even orders largely absent in a balanced design. Including a ninth-order term to chase a product 60 dB down wastes coefficients and risks conditioning trouble for a correction the spectrum analyzer can barely see. The builder fits the smallest model that captures the visible distortion, checks the residual, and adds a term only if a specific product remains uncorrected, growing the model from evidence rather than guessing large and hoping.

Conditioning of the basis matrix governs whether the solution is trustworthy. The memory-polynomial terms are correlated, since high powers of the same signal resemble one another, and that correlation makes the matrix X nearly singular, so its inverse amplifies noise. The cure is orthogonalization, rebuilding the basis from orthogonal polynomials whose terms are uncorrelated, which dramatically improves the conditioning and lets the least-squares solver find stable coefficients. An implementation using an orthogonal memory polynomial basis is exactly what the practical software-defined radio designs adopt, trading a one-time basis transformation for a numerically robust solution that the radio can recompute reliably on every update.

How fast the loop must learn and when it can stop

The adaptive loop has a clock, and matching its speed to the amplifier's drift is the final design decision. The amplifier's fastest meaningful change is thermal, governed by a time constant of milliseconds to seconds depending on the device and heat sink, so the coefficient update must run faster than the amplifier wanders but no faster than it usefully can. Updating every few milliseconds tracks thermal drift with margin; updating every microsecond wastes computation chasing changes that are not there and amplifies measurement noise into the coefficients.

A simple convergence criterion tells the loop when it has learned enough. The residual error power, the mean square of the difference between desired and actual output, falls as the coefficients converge and then plateaus at the noise floor. The loop monitors that residual and slows its updates once it stops improving:

stop when | E_residual(n) - E_residual(n-1) | < threshold

Quantify a typical convergence. If each least-squares update reduces the residual error power by 30 percent of its remaining distance to the floor, then after one update 70 percent of the excess remains, after two updates 0.7 squared or 49 percent, and after five updates 0.7 to the fifth or about 17 percent. Reaching within one percent of the noise floor takes roughly

n = log(0.01) / log(0.70) = -4.6 / -0.357 = 13 updates

so a dozen or so updates bring the predistorter to its full performance from a cold start, after which it idles, applying small corrections only as the amplifier drifts. This is why a software-defined radio transmitter shows its distortion collapsing within a fraction of a second of keying up and then holding steady, the loop having learned the amplifier quickly and thereafter merely defending the solution against slow thermal change.

Where the technique strains and how the radio copes

The method is not without its difficulties, and the software-defined radio architecture shapes them. The first is bandwidth. The predistorter generates correction terms at higher orders, and a third-order or fifth-order term occupies three or five times the bandwidth of the original signal, so the digital-to-analog converter and the feedback receiver must handle several times the signal bandwidth or the correction is truncated and incomplete. A radio correcting a wide signal needs proportionally wide converters, and this bandwidth expansion is often the limiting practical constraint.

The second difficulty is the non-static behavior the learning loop exists to chase. The amplifier model changes with dynamic operating conditions, and if the input power level swings, as it does when a system dynamically allocates resources, the coefficients valid at one power become wrong at another. One elegant response decomposes the coefficient set into a common part valid across all power levels and a correction part adjusted by scaling factors as the power changes, so the radio adapts to power swings by tuning a few scaling factors rather than recomputing the whole solution. This keeps the linearization correct as the operating point moves without the cost of a full recalibration each time.

The deeper significance is what digital predistortion reveals about where intelligence belongs in a radio. The analog amplifier is a fixed, imperfect physical object, and rather than perfecting the object, the software-defined radio surrounds it with computation that measures its imperfection and cancels it. The amplifier does not get better; the radio gets smarter about driving it. The correction lives in software, so it improves as algorithms improve, adapts as conditions change, and costs nothing in hardware beyond the converters and the processing. This is the pattern that defines the software-defined radio era: when a physical component cannot be made ideal, wrap it in adaptive computation that learns its flaws and undoes them in real time, turning a cheap nonlinear amplifier driven hard into the equivalent of an expensive linear one driven gently, at a fraction of the power and the cost.