🤖 machine learning

EXPLORE: Exploration with Guided Search for Analog Topology Generation using Language Models

This paper introduces EXPLORE, a novel framework that combines language model priors with simulator-guided Monte Carlo Tree Search to significantly improve the success rate and performance of automated analog circuit topology generation compared to existing one-shot and sampling-based methods.

Original authors: Guanglei Zhou, Chen-Chia Chang, Yikang Shen, Jonathan Ku, Isaac Jacobson, Jingyu Pan, Yiran Chen, Xin Zhang

Published 2026-07-16

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Guanglei Zhou, Chen-Chia Chang, Yikang Shen, Jonathan Ku, Isaac Jacobson, Jingyu Pan, Yiran Chen, Xin Zhang

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 are an architect, but instead of designing houses, you are designing tiny, invisible machines called analog circuits. These are the unsung heroes inside your phone, your car, and your laptop, handling things like turning battery power into the right voltage for a screen or cleaning up a noisy radio signal. For decades, building these circuits has been a slow, manual art form. A human expert has to sketch a design, run a computer simulation to see if it works, realize it's broken, erase it, and start over. This cycle repeats hundreds of times for a single design. It's like trying to find a specific needle in a haystack by building a new needle for every single piece of hay you pick up, hoping one of them is the right one.

Recently, scientists tried to teach computers to do this sketching using "language models"—the same kind of smart AI that can write stories or answer questions. They taught these AIs to read a set of rules (like "I need a circuit that doubles the voltage") and instantly spit out a drawing of a circuit. But there was a catch: these AIs were like students who memorized a few simple recipes but panicked when asked to cook a complex banquet. If the circuit got a little bigger or more complicated, the AI would just guess a random, broken design. It didn't know how to "think" about its mistakes or try again. It was a "one-shot" attempt: guess once, and if you fail, you fail.

This is where a new paper titled EXPLORE steps in. The researchers, a team from Duke University and IBM, realized that instead of forcing the AI to get it right on the first try, they should let the AI "think out loud" and explore different options before committing to a final design. They built a system that combines the AI's creativity with a rigorous search process, kind of like a detective who doesn't just guess the culprit but checks every clue, follows every lead, and only arrests the suspect when the evidence is solid.

The Problem: The "One-Shot" Trap

To understand why EXPLORE is special, imagine you are playing a game of "Guess the Drawing." You have to draw a picture of a cat, but you can only make one single stroke of the pen. If you mess up the ear, the whole cat is ruined. That is how the old AI methods worked. They would look at your request and immediately draw a full circuit. If the circuit didn't work, the AI had no way to fix it; it just had to try again from scratch.

The problem gets worse as the circuit gets bigger. The paper explains that as you add more parts (like capacitors, inductors, and switches) to the circuit, the number of possible ways to connect them explodes. It's like trying to solve a puzzle where the number of pieces doubles every time you add one more piece. For a simple circuit with 3 or 4 parts, the AI could guess the right answer easily. But for a circuit with 6 parts, the number of wrong guesses is so huge that the AI gets lost. The old methods tried to brute-force this by generating thousands of random guesses and hoping one worked, but this was incredibly slow and inefficient.

The Solution: A Guided Search

The EXPLORE framework changes the game by introducing a "guided search." Instead of the AI just spitting out a final answer, it acts like a climber scaling a mountain. The climber (the AI) has a map (its training data) that tells it where the path probably goes. But the mountain is steep and foggy, so the climber doesn't just walk blindly.

Here is how EXPLORE works, step-by-step:

The Map (The Language Model): The AI starts with a "map" it learned from looking at thousands of existing circuits. This map gives it a good hunch about what a valid circuit looks like.
The Branching Paths (Monte Carlo Tree Search): When the AI needs to make a decision (like "should I connect this wire here or there?"), it doesn't just pick one. It imagines several different paths forward. This is called a "tree search." It's like standing at a fork in the road and imagining walking down both paths to see which one leads to a better view.
The Reality Check (The Simulator): For each path the AI imagines, it runs a quick "test" using a circuit simulator. This is the moment of truth. The simulator says, "Hey, if you connect it that way, the voltage is wrong," or "Great job, this part works!"
The Smart Skip (P-Filtering): This is a clever trick the researchers invented. In the language the AI uses to describe circuits, about half the words are just "grammar" words—like "the" or "and"—that don't actually change the design. They are just there to make the sentence look right. The EXPLORE system realizes that if the AI is 99% sure about one of these grammar words, it doesn't need to waste time testing them. It just auto-accepts them and saves its energy for the real decisions. This is like a chef who doesn't need to taste the salt shaker before adding salt; they just know to add it and save their tasting time for the soup itself.

What They Found

The team tested this new method on circuits with 6 components, which is a sweet spot where the old methods start to struggle. They set a very strict goal: the circuit had to be perfect within a tiny margin of error (0.01).

The Old Way: When the AI tried to guess the circuit in one shot (the "Greedy" method), it succeeded only 12% of the time. Even when they tried a method that generated many random guesses and picked the best one ("Sampling and Filter"), it only succeeded 33% of the time.
The EXPLORE Way: With their guided search, the success rate jumped to 65%. That is more than double the success of the best previous method.

But it wasn't just about winning more often; it was about being smarter. The paper notes that EXPLORE made errors (measured by something called "Mean Squared Error") that were more than 20 times smaller than the random guessing method. This means the circuits it did find were much closer to the perfect target.

The researchers also looked at even bigger challenges: circuits with 7, 8, and 9 components. In these complex scenarios, the old methods basically gave up, with success rates dropping to near zero. EXPLORE, however, kept working. While it didn't solve every single problem perfectly, it was the only method that could still find any working designs in these difficult, uncharted territories.

Why It Matters

The paper suggests that this approach is a major step forward because it teaches the AI to "think" before it acts. Instead of relying on a massive database of every possible circuit (which is impossible to collect), EXPLORE uses the AI's intuition to guide a smart search, checking its work as it goes.

The authors are careful to note that while this is a huge improvement, it's not a magic wand that solves everything instantly. The success rates for the very largest circuits (10 components) were still modest, and the system requires a lot of computer power to run the simulations. However, by proving that a "search-enhanced" approach works better than a "one-shot" guess, they have opened a new door. It suggests that the future of circuit design won't just be about smarter AI models, but about smarter ways to let those models explore, test, and refine their ideas before they ever build a single physical chip.

In short, EXPLORE is like giving the circuit designer a compass and a map, rather than just blindfolding them and hoping they stumble upon the treasure. It turns a game of pure luck into a game of strategy.

Technical Summary: EXPLORE – Exploration with Guided Search for Analog Topology Generation

Problem Statement

Automating analog circuit topology design is critical for meeting diverse application demands, yet traditional workflows rely heavily on manual iteration and domain expertise. While recent advances have applied sequence-to-sequence fine-tuning on pretrained language models (LMs) to generate circuit topologies in a single pass (e.g., LaMAGIC), these "one-shot" methods face significant bottlenecks:

Exponential Search Spaces: The number of possible topologies grows combinatorially with the number of components. For circuits with 6 or more components, the search space becomes too vast for existing datasets to provide sufficient coverage.
Data Scarcity: High-quality training data for complex circuits (7–10 components) is difficult to obtain via random enumeration due to the high fraction of invalid or low-efficiency topologies.
Inefficiency of One-Shot Generation: When the initial LM decoding produces a structurally invalid or off-spec circuit, one-shot methods lack a mechanism to spend additional compute to refine the solution, leading to near-zero success rates for complex designs.

Methodology: The EXPLORE Framework

EXPLORE addresses these limitations by integrating simulator-guided Monte Carlo Tree Search (MCTS) with transformer-based decoding. Rather than relying solely on the LM's initial generation, EXPLORE treats topology generation as a guided search problem where the LM acts as a prior to direct the search, and a circuit simulator (NGSPICE) provides feedback to evaluate candidates.

Core Components

LM-Guided MCTS:
- Selection: Uses the PUCT (Upper Confidence Bound for Trees) algorithm, incorporating the LM's token probabilities as action priors ( $P(a|s)$ ) to bias selection toward plausible and under-explored continuations.
- Expansion (p-filtering): A key innovation is the bypassing of "structural tokens." In the text-based circuit formulation (Float-Input Adjacency Matrix), many tokens are syntactically required but carry no topological choice (e.g., fixed separators or "no edge" tokens). If the LM assigns a probability $\ge p$ (set to 0.99) to a token, EXPLORE auto-commits it without spawning new search branches. This skips 24–48% of simulation trials, focusing the expensive simulator budget on genuine topological decisions.
- Evaluation: Partial topologies cannot be simulated directly. EXPLORE uses beam search to complete the sequence from the current node, then simulates the full circuit in NGSPICE to calculate a reward based on voltage conversion ratio and efficiency errors relative to the target.
- Backpropagation: Rewards are backpropagated to update node values and guide future search iterations.
Two-Stage Dataset Construction:
To overcome the lack of high-quality data for complex circuits, the authors propose a two-stage pipeline:
- Stage 1: Expand random enumeration to bootstrap data for 6–10 component circuits, retaining only structurally valid topologies.
- Stage 2: Use the trained model, guided by the EXPLORE search procedure, as a "model-native" data generator. Because the search biases expansion toward plausible edges and simulator feedback steers toward high efficiency, this stage yields a significantly higher fraction of useful samples (e.g., increasing the fraction of >90% efficiency circuits from 8.3% to 23.3% on 6-component tasks) compared to random enumeration.

Key Contributions

First Test-Time Scaling Framework: EXPLORE is the first work to apply test-time scaling to analog topology generation, utilizing an LM-guided MCTS as a decoder and reusing the search process as a data-collection engine.
Structured Token Filtering: The introduction of p-filtering allows the framework to bypass high-confidence structural tokens, making the scaling to higher-complexity circuits computationally feasible by reducing the simulation budget.
Scalability Beyond One-Shot: The framework enables the generation of circuits with 7, 8, and 9 components, a regime where one-shot LM decoding fails (success rates drop to near-zero) and where prior datasets do not cover.

Experimental Results

The framework was evaluated on power converter benchmarks with varying component counts (6–10) and strict tolerance targets ( $t=0.01$ ).

6-Component Benchmark:
- Success Rate: EXPLORE achieved a 65% success rate, significantly outperforming the one-shot LaMAGIC baseline (12%) and a sampling-and-filter baseline (33%).
- Error Reduction: Under the same search budget, EXPLORE reduced the Mean Squared Error (MSE) for voltage and efficiency by over 20× compared to the sampling-and-filter baseline.
- Efficiency: The method converged faster than an MCTS variant without LM guidance (MCTS-Base), demonstrating the value of LM priors in node selection.
7–10 Component Scalability:
- As component count increased, all methods showed degradation, but EXPLORE consistently maintained the highest success rates.
- On 7, 8, and 9-component circuits, EXPLORE achieved 10×, 13×, and 4× higher success rates, respectively, compared to the greedy baseline.
- Even on 10-component circuits (which were outside the 6–9 training range), EXPLORE remained the top-performing method, demonstrating a scalability trend absent in training data.

Significance and Claims

The paper positions EXPLORE as a practical step toward scaling Large Language Model (LLM)-driven design automation. It argues that existing approaches, constrained by limited datasets, cannot scale topology generation on their own. By integrating structured test-time search with LM decoding, EXPLORE overcomes the "one-shot" bottleneck, allowing for iterative refinement guided by simulator feedback.

The authors modestly note that while the results demonstrate a clear scalability trend, absolute success rates for circuits beyond 8 components remain modest, indicating that the framework is a proof of concept for scaling rather than a fully mature solution for all complex industrial designs. The work establishes a new paradigm where search and learning are embedded directly into the design flow to explore vast, sparse design spaces efficiently.