Direct Learning Architecture (DLA) is a closed-loop adaptive predistortion topology that directly identifies the predistorter parameters by minimizing the error between the power amplifier's (PA) actual output and a scaled version of the ideal input signal. Unlike the Indirect Learning Architecture (ILA), DLA does not assume commutability of the nonlinear predistorter and PA blocks, making it theoretically more accurate for strongly nonlinear systems where the postdistorter and predistorter are not interchangeable.
Glossary
Direct Learning Architecture (DLA)

What is Direct Learning Architecture (DLA)?
A closed-loop predistorter training topology where the neural network coefficients are updated by minimizing the error between the power amplifier's output and the desired linear reference signal.
In DLA, the error signal is computed after the PA, and the gradient of this error with respect to the predistorter coefficients is propagated back through a model of the PA. This requires either a pre-identified PA behavioral model or an approximate real-time gradient estimation, often implemented via backpropagation through time (BPTT) for recurrent structures. The architecture inherently compensates for PA memory effects and parameter drift due to temperature and aging, making it the preferred topology for high-performance wideband signal linearization in 5G and radar transmitters.
Key Characteristics of Direct Learning Architecture
The Direct Learning Architecture (DLA) distinguishes itself from open-loop methods through its closed-loop error minimization approach. By comparing the power amplifier's actual output directly against the desired linear reference signal, DLA enables adaptive, real-time coefficient updates that compensate for time-varying PA nonlinearities.
Closed-Loop Error Minimization
DLA operates by forming a closed feedback loop where the predistorter coefficients are updated based on the error between the power amplifier's output and the desired linear reference signal. Unlike Indirect Learning Architecture (ILA), which assumes commutability of nonlinear blocks, DLA directly minimizes the true linearization error. The error signal is computed as:
e(n) = y_PA(n)/G - x(n)
where y_PA(n) is the PA output, G is the linear gain, and x(n) is the reference input. This direct error formulation eliminates the model mismatch inherent in postdistorter-based approaches.
Adaptive Coefficient Update Mechanisms
DLA employs iterative optimization algorithms to update neural network weights in real-time:
- Stochastic Gradient Descent (SGD): Updates coefficients sample-by-sample using the instantaneous gradient of the error surface
- Levenberg-Marquardt Algorithm: Provides faster convergence for batch-mode training by interpolating between Gauss-Newton and gradient descent
- Recursive Least Squares (RLS): Offers rapid convergence for linear-in-parameters predistorter structures
The update rule for a neural DLA predistorter using SGD is:
w(n+1) = w(n) - μ * ∇J(w)
where μ is the learning rate and ∇J(w) is the gradient of the mean squared error cost function with respect to the network weights.
Real-Time Online Training Capability
A defining advantage of DLA is its ability to perform online learning during live signal transmission. This enables the predistorter to track:
- Thermal memory effects: PA characteristics drift as the transistor junction temperature changes during operation
- Aging effects: Gradual degradation of PA linearity over months and years of deployment
- Supply voltage variations: Envelope tracking systems that dynamically modulate the drain voltage
- Load impedance changes: Antenna mismatch conditions in mobile handsets
The online training loop continuously minimizes the Adjacent Channel Leakage Ratio (ACLR) and Error Vector Magnitude (EVM) without interrupting service.
Gradient Computation via Backpropagation Through Time
For recurrent neural network (RNN) based predistorters within a DLA framework, the gradient of the error with respect to network parameters is computed using Backpropagation Through Time (BPTT). The process involves:
- Unrolling the RNN's temporal operations over a finite sequence length
- Propagating the error signal backward through the unrolled computational graph
- Accumulating gradients across time steps to update shared weights
This is computationally more intensive than standard backpropagation but essential for capturing the long-term memory effects of GaN Doherty power amplifiers in 5G base stations.
Model Extraction and Initialization
Before online adaptation begins, DLA requires an initial predistorter model. This is obtained through offline model extraction:
- A training signal (typically an OFDM waveform with high PAPR) is transmitted through the PA
- The PA input and output are captured synchronously using a vector signal analyzer
- The neural network is trained offline to minimize the linearization error
- The converged weights serve as the initialization point for online adaptation
Proper weight initialization using Xavier or He initialization is critical to ensure stable gradient flow when online training commences.
Convergence and Stability Constraints
DLA's closed-loop nature introduces stability considerations not present in open-loop architectures:
- Learning rate sensitivity: An excessively high learning rate
μcan cause the predistorter coefficients to oscillate or diverge, potentially damaging the PA - Loop delay compensation: The feedback path delay must be accurately estimated and compensated to align the reference and feedback signals in time
- Gain normalization: The PA's linear gain
Gmust be precisely estimated to scale the feedback signal correctly before error computation - Regularization: L2 weight decay or dropout regularization prevents overfitting to specific signal characteristics during online adaptation
These constraints require careful hyperparameter tuning on validation datasets before deployment.
DLA vs. Indirect Learning Architecture (ILA)
Structural and operational comparison of the two dominant adaptive predistorter coefficient estimation topologies.
| Feature | Direct Learning Architecture (DLA) | Indirect Learning Architecture (ILA) |
|---|---|---|
Training Topology | Closed-loop | Open-loop |
Error Signal Source | PA output vs. desired linear reference | Postdistorter output vs. predistorter input |
Nonlinearity Assumption | No commutability assumption required | Assumes commutability of nonlinear blocks |
Adaptation Mechanism | Minimizes output error directly | Trains postdistorter, then copies to predistorter |
Sensitivity to PA Noise | Low; noise is in the optimization loop | High; noise is learned by the postdistorter |
Model Copy Step | ||
Convergence Robustness | Guaranteed for convex cost functions | May diverge if commutability assumption fails |
Hardware Implementation Complexity | Higher; requires output observation receiver | Lower; uses input-side signal comparison |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Frequently Asked Questions
Clear, technically precise answers to the most common questions about the closed-loop Direct Learning Architecture for neural network predistorter training.
A Direct Learning Architecture (DLA) is a closed-loop predistorter training topology where the neural network coefficients are updated by directly minimizing the error between the power amplifier's (PA) output and the desired linear reference signal. Unlike the Indirect Learning Architecture (ILA), DLA does not assume commutability of the nonlinear blocks. The system feeds the predistorted signal through the physical PA, measures the actual distorted output, and computes the error signal e(n) = y_{desired}(n) - y_{PA}(n). This error is then backpropagated through a PA behavioral model to compute the gradient with respect to the predistorter's parameters, enabling true closed-loop adaptation that inherently compensates for model imperfections and time-varying PA characteristics.
Related Terms
Key concepts and architectural variants that define how neural network predistorters are trained in closed-loop configurations.
Indirect Learning Architecture (ILA)
The primary alternative to DLA. In ILA, a postdistorter is trained on the PA's output to estimate the inverse nonlinearity, then copied to the predistorter position. This assumes nonlinear block commutability, which breaks down under strong memory effects. DLA avoids this assumption by training the predistorter directly in its operational position, using the PA output fed back through the observation receiver.
Backpropagation Through Time (BPTT)
The gradient computation algorithm required to train recurrent neural network predistorters within a DLA framework. Since the PA introduces temporal dependencies, the network must be unrolled through time to propagate the error signal backward through the sequence. BPTT enables the DLA to capture long-term memory effects in GaN and Doherty amplifiers.
Online Learning
An adaptive training paradigm where DLA coefficients are continuously updated during live signal transmission. This closed-loop adaptation tracks time-varying PA characteristics caused by:
- Thermal drift during operation
- Aging effects over component lifetime
- Supply voltage fluctuations Online DLA eliminates the need for periodic offline recalibration.
Observation Receiver Path
A critical hardware component in DLA systems that attenuates and downconverts the PA output for feedback comparison. The observation path must maintain:
- Higher linearity than the PA under test
- Sufficient bandwidth to capture distortion products
- Phase coherence with the reference signal Any nonlinearity in this path corrupts the error signal and degrades DLA convergence.
Model Generalization
The ability of a DLA-trained predistorter to maintain linearization performance across unseen signal conditions. A well-generalized DLA model handles:
- Varying signal bandwidths and PAPR
- Different modulation schemes (QAM, OFDM)
- Temperature and frequency drift Techniques like dropout regularization and data augmentation prevent overfitting to the training signal.
Inference Latency
The fixed computational delay between input sample arrival and predistorted output generation. In DLA, this is a hard real-time constraint—the latency must be less than one sample period for wideband signals. For a 100 MHz 5G NR signal, this requires processing within < 10 nanoseconds, driving the need for FPGA-optimized, quantized neural network implementations.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us