Enhancing micro-architecture optimization using explainable fuzzy neural networks with multi-fidelity reinforcement learning

Machine learning approaches to micro-architecture optimization

Machine learning (ML) has made a significant contribution to micro-architecture design space exploration (DSE). Modern techniques optimize by using ML algorithms to search complex, multidimensional design spaces effectively. Genetic algorithms (GAs) have been known to explore large design configurations (Mitsas, 2024; Spencer et al., 2024). These optimization strategies simulate natural selection, whereby solutions are found through the use of mutation and crossover. Nonetheless, to ensure that the genetic algorithms perform optimally, they must be well-tuned in advance.

The other popular ML solution in DSE is Bayesian optimization. It traverses a parameter space to find promising configurations as rapidly as possible (Zhang et al., 2024). Compared to more exhaustive search methods, Bayesian optimization saves a great deal of time used on exploration. Nevertheless, Bayesian approaches are considered black-box models, although they have these benefits. Reasons behind the optimization decisions are hard to grasp by the designers. On the same note, methods involving random forests provide effective prediction of performance results but are not easily interpretable (Kundu et al., 2024; Zaourar, Munier-Kordon & Fu, 2024).

In general, the efficiency of exploration is boosted considerably using ML methods. But one disadvantage of theirs is limited interpretability. This limitation makes it difficult to incorporate human knowledge when making the automation design decisions (Inayat et al., 2024; Xue et al., 2024). Table 1 shows these methods, their characteristics, strengths, and weaknesses.

Multi-fidelity simulation methods

Multi-fidelity modeling seeks to deal with this aspect of critical balancing between accuracy and computational efficiency when it comes to micro-architecture optimization. The traditional single fidelity simulation is categorized into two. High-fidelity simulations have good accuracy but are costly in computation. On the other hand, a low-fidelity simulation will give quicker results and compromise accuracy (Zhao et al., 2025).

Strategic combinations of the two are used in a multi-fidelity simulation approach. First, they apply low-fidelity simulations to quickly search a broad scope of designs. The potentially promising arrangements discovered in this phase are tested with high-fidelity simulations to be validated and improved. This process reduces computation costs compared to using high-fidelity models alone, though combining simulations adds complexity (Li et al., 2024). Switching between low- and high-fidelity simulations is an action that needs calibration.

More recent multi-fidelity techniques are efficiently used in the optimization of specialist hardware, like deep neural network accelerators. Such approaches exhibit a high level of efficiency and accuracy in trade-offs. Nevertheless, even though multi-fidelity simulation strategies turn out to be successful, they are frequently not transferable to other contexts (Wang et al., 2025; Ardalani, Pal & Gupta, 2024). Their greater use in optimizing general-purpose micro-architecture is inhibited by this specialization. Table 2 compares multi-fidelity simulation techniques, comparing their major features and strengths and weaknesses.

Explainability in micro-architecture optimization

Explainability is increasingly vital in micro-architecture optimization, as designers require clear processes to understand automated design decisions. Conventional ML and optimization find themselves in the black box, where it is not easy to comprehend the reasoning behind respective decisions (Wang et al., 2024). This opacity prevents trusting and using automated recommendations effectively as designers.

This is an issue that has been developed recently by incorporating explainability in the optimization methods (Jan, 2024; Li et al., 2025). Another efficient method is the combination of fuzzy logic and neural networks. The hybrid also produces these readable decision rules in a human-readable form, which makes clear the reasoning behind why optimization decisions were arrived at. Fuzzy logic may allow the designer to know more and correct the outcomes of exploration because of its transparency (Lan et al., 2025).

However, full interpretability cannot be attained, especially in highly complex processor designs. As the processors’ set-up becomes complex to handle, it is getting harder to generate simple and meaningful decision rules (Karthikeyan & Manimegalai, 2025; Benfatma, Khouidmi & Bessedik, 2025). In addition, the interpretability and the scalability of the methods can be incompatible. The ability to accomplish these two at the same time is still a major open task. Recent trends and unsolved problems in explainable micro-architecture optimization are summarized in Table 3.

Research gap and summary

ML-based methods, multi-fidelity simulations, and explainable frameworks each have distinct strengths. The ML methods successfully navigate large design spaces and are opaque. Multi-fidelity algorithms trade off accuracy and computational cost but has in practice calibration difficulty. Transparency using explainable methods benefits, although they can frequently be at scale to complex systems.

A gap in current research still exists between good integration of interpretability, efficiency, and scalability into one optimization framework. To reduce this gap, new solutions are needed that introduce the accuracy of the interpretability of fuzzy logic and neural networks combined with the effectiveness of multi-fidelity reinforcement learning. These techniques would provide useful ways of controlling automated optimization techniques, also to more complex processor designs.

System setup and materials

We implemented the framework on a high-performance computing cluster with multi-core processors and GPUs to handle computations for multi-fidelity simulations and reinforcement learning. This cluster runs low-fidelity models to quickly explore the design and can transition to high-fidelity simulations for detailed information, thereby efficiently couple resources with the design exploration phase.

Low-fidelity model

This was accomplished through a combination of low-fidelity models that are derived from high-level architecture space exploration of processors, which approximate performance attributes like execution time, power consumption, and area. These models link ideal kinematic performance studies with historical data and serve as computationally inexpensive performance estimates that can be used to evaluate design configurations before the optimization process. The actual predictions are built from models trained on statistical learning data, where performance is predicted based on design parameters like cache size and pipeline depth. Table 4 indicates that we observed that these models are very efficient while less accurate than the high-fidelity simulations.

High-fidelity model

However, the high-fidelity models used in this approach rely on RTL simulations to deliver precise performance predictions. Using hardware description language (HDL), these simulations can model the processor at a detailed level, showing how the various components in the processor interact with each other. High-fidelity simulations decide a design configuration finalized from the initial low-fidelity exploration phase. These methods require more computational power but are needed for filtering and validating the outcomes received from the first phase.

Data sources and preprocessing data sources and preprocessing

In our scenario, the training models are familiar with a lot of processor design benchmarks meaning, real-life examples of processor setups and their performance characteristics. This data is then subjected to preprocessing, which includes normalizing values, removing outliers, and dealing with missing data, to make sure they are high quality and can be used for training. Dictionaries using forms of selection, these functions allow identifying the most influential design parameters that affect the processor performance are further processed on the datasets. The latter dataset is used as input for the FNN as well as MFRL framework.

Data details

The processor design benchmarks used in this study were based on commonly accepted processor performance datasets, such as those from SPEC CPU 2006 (a well-known benchmark for processor performance evaluation, available at SPEC CPU 2006) (http://www.spec.org/cpu2006/). These benchmarks provide comprehensive processor performance data for various configurations. The performance metrics evaluated, including execution time, power consumption, and area efficiency, were measured using this dataset. The dataset was then preprocessed through standard methods, including normalization, outlier removal, and handling of missing data using Python’s Pandas and NumPy libraries (available at Pandas and NumPy).

For additional evaluation, custom simulation datasets were generated based on performance data from simulations conducted in-house. These simulations were designed to model various processor configurations using both low-fidelity and high-fidelity simulations, which were then used to optimize processor design configurations.

Methodology overview

The methodology is built on two pillars: A FNN to deliver interpretable models, and a MFRL strategy to optimize these parameters. The FNN offers the explainability of design decisions, and the MFRL explores the design space efficiently using a family of low- and high-fidelity models. These components interact in an iterative process to explore the design space and find optimal processor configurations as shown in Fig. 2.

Fuzzy neural network

The FRNN enables the interpretability of the optimization process. Fuzzy neural networks can be developed as an extension of a neural network by integrating neural networks, which can adapt their weights, with the transparent nature of fuzzy logic that describes the underlying relationship among the design parameters using fuzzy if-then rules. In this article, we followed the rules of human understanding to clarify the optimization process, providing a mechanistic based explanation which can be applied in terms understandable for the designer and therefore bridging the gap between machine learning models and human-readable design insights.

An FNN model scheme includes an input layer, fuzzy layer and output layer. This synchronous neural article consists of input, hidden and output layers. The fuzzy layer uses fuzzy logic to convert these inputs into fuzzy values processed by the neural network. During classification, the output layer produces human-readable decision rules allowing interpretation of the implications of design parameters on performance outcomes. This set of fuzzy rules facilitates interpretability in the optimised decision making and helps to make optimization paths more visual, as can be seen in Table 4.

FNN architecture details

The model of FNN is composed of three operating layers input, fuzzy, and output. The inputs contain core design parameters: the size of the cache, the depth of the pipeline, and the width of the memory. Use of the triangular membership functions converts crisp input values into fuzzy sets, using the fuzzy layer. Each fuzzy rule has an interpretable format of IF-THEN that links design variables with the performance behavior. This consists of no more than 10 or 15 fuzzy rules so that they may be interpretable. The performance results are constrained to performance such as execution time or power which is mapped by the output layer using fuzzy values. The design assists in producing clear opinions in the process of design optimization.

Multi-fidelity reinforcement learning

The methodology of MFRL evolves the design space effectively. Many approaches are classified as MFRL, which involves a two-phase exploration process wherein the large design regions are first searched quickly at low fidelity and the configurations pointed out in this phase are refined at high fidelity. The framework adopts both types of models to expeditive regulation of the design space exploration and to reduce the number of costly simulations.

The following appropriate basic definition of a Markov decision process is represented under MFRL, where state-space is a processor configuration, and action-space represents the possible changes or optimizations to the design parameters. The reward function is defined over the execution time, power consumption and area performance metrics. The reward mechanism provides feedback to the agent about whether the design it chose was good or bad, guiding the exploration to better configurations. The two-stage consideration is evidenced in Table 5, where the early generations utilize low-fidelity models, while the high-fidelity assessments are performed towards the end for final selection and verification of the design configurations.

RL training

The exploration and exploitation process is balanced using an ε-greedy strategy during the RL training process. In the training, the learning rate is 0.01 with a discount factor of 0.9. Convergence of the training occurs in 500 episodes, which is measured by reward and performance measures. The state space contains coded-processor combos. The actions change one or more design parameters. The reward is a weighted sum of the execution time, area and power penalizing poor trade-offs. This arrangement maintains a stable and consistent learning environment in the design space exploration.

Learning algorithms

Optimum design space and minimum computation time accuracy are based on learning algorithms. This basic framework consists of three major algorithms: Q-learning, Deep Q-Network (DQN), and fuzzy rule extraction from the trained FNN. These algorithms were designed with different goals in optimization process.

Algorithm 1 presents the Q-learning for Multi-Fidelity Exploration, enabling the agent to learn from the design-space interactions exploited to minimize its design costs. Learn the parameters used in Q-learning to find the optimal policy. This algorithm is used in the first low-fidelity exploration phase, when the space of states is massive and we must end up with as few simulations as possible. The agent uses the Q-values to take actions, and updates the Q-values based on each interaction with the design space, as presented in Algorithm 1.

The DQN estimates the Q-values using a deep neural network (DNN), enabling it to tackle high-dimensional state space problems. Thus, the network is trained from a replay buffer: a memory of past experiences, so as to stabilize the learning process. Such algorithm is used when it scales the design exploration process to larger and more complex configurations. The DQN is trained iteratively as shown in Algorithm 2, so as to approximate the optimal policy.

It provides the Fuzzy if-then rules that are extracted from the trained FNN. Thus, generated Convolutional Neural Network (CNN) design rules present interpretable knowledge about the design optimization process, allowing designers to directly see how specific design choices contribute to the performance of their network. A trained FNN model is used to generate human interpretable fuzzy rules, and the process is explained in Algorithm 3.

Integration of FNN and MFRL

The suggested algorithm has two stages of a two-layer hybrid system that combines FNN and MFRL. The level of simulations has low fidelity in this initial stage, with the Q-learning method being used in fast exploration. The second stage is where the trained configurations are tested on a high-fidelity environment using DQN simulation. In both of the stages, FNN produces human-interpretable fuzzy rules that are used in exploration and also enable designers to interpret decisions. Such an arrangement has increased efficiency and interpretability. The fuzzy rules impact the exploration process and discover relationships among design features as characterized by Table 6.

Evaluation and performance metrics

We demonstrate the effectiveness of our proposed framework by applying it to standard microprocessor design benchmarks. Performance metrics for evaluation are execution time, power consumption, area, and area−delay product. These metrics give a holistic view of design performance and help an agent to make design decisions. As presented in Table 7, the framework optimizes designs based on a weighted sum of these metrics which incentivizes exploration of configurations that reduce execution time (ET) and power consumption (PC) while occupying less area (A).

The point of comparison in our experiments is a standalone design space exploration process based on high-fidelity simulations and a random parameter search approach. It does not contain learning-based optimization nor explainability. Any type of performance comparison is done to this benchmark based on the aspects of design, speed, and resource consumption.

Comparison of execution time

Optimization aims at minimizing the execution time of the processors. All optimized configurations are better compared to gain at baseline. The least overall execution time is provided by optimization 1. In Config 1, there is an improvement of 10 percent. Config 5 does 25 percent better. These are indicated in the Fig. 3 and Table 8. The combination of FNN and MFRL designs the space of designing comprehensively to achieve fast and valid decision-making.

Power consumption: a comparison

Energy is a vital aspect, particularly in embedded systems. Each configuration is lower powered than the baseline. The most significant reduction pertains to Optimization 1, which is 10 percent in Config 1 and 20 percent in Config 5. These reductions are portrayed in Fig. 4 and Table 9. FNN enables power-aware design paths to be refined and MFRL accelerates exploration. A combination of both is better than Optimization 3 because Optimization 1 performs better.

Area efficiency

Embedded systems Processor size is important. In terms of area efficiency optimization 1 comes first. Config 1 uses 5 percent area reduction. Config 5 gives 13%. Figure 5 and Table 10 are the results.

This has been done due to the utilization of fuzzy rules. These are the rules that assist in balancing trade-offs between area and performance. Optimization 2 finds area improvements but those are smaller compared to Optimization 1 that explores more through MFRL.

Area-delay product

Area-delay product is a measure of reasonableness of chip size and speed. A lower the better. Optimization 1 once again works best. It decreases by 12% in Config 1 and by 15% in Config 5. Figure 6 and Table 11 depict the results. This makes it true that the approach results in compact and fast processor designs.

In addition to individual metrics, on the aggregate level, the efficiency is measured on the basis of a composite reward function. This is a combination of power, area and execution time. Greater rewards are signs of improved overall designs. The rewards show balance in trade-offs.

Reward comparison

In every parameter, the highest reward can be seen with Optimization 1. Config 5 has 160 percent better improvement over the baseline. This is confirmed in Fig. 7 and Table 12. FNN and MFRL have a balanced design that outweighs other methods. Optimization 2 and 3 do not have this balance. The suggested approach brings about economic performance in every design dimension.

Design time (simulation time) and memory usage

Practical processor design is dependent on design time and memory usage. All the optimization strategies lower simulation time compared with the baseline. The Design time with optimization 1(FNN + MFRL) yields the fastest design time. Optimization 3, too, gives a marked speedup. Table 13 shows these time gains. With regard to memory, the baseline configurations would need less memory than the optimized ones. Optimization 1 performs best as regards memory efficiency. There is a summary Tables 14 and 15 of memory use over configurations. This validates our approach with regard to scalability and practicability.