Tutorial about circuit design optimization

[dietmarwo]

From the paper:

"Most of the commercially available software provides an interface to perform paramet-
ric analysis on a design. However, if we want to generate different versions of a circuit, each
version has to be generated by hand (e.g., a flash ADC with different number of bits), thus
reducing the possible space of exploration due to time or complexity constraints. With our
tool, parametric characteristics can be embedded directly into the components and the
multiple designs can be generated in a modular and programmable fashion."

That is really interesting.

Optimizing circuit design involving both topology and parameters looks challenging for several reasons:

• The necessity to optimize both discrete (topology) and continuous parameters, which are interdependent and cannot be optimized separately.
• The vast search space requiring the evaluation of an extensive array of potential designs.

Thanks to the capabilities of modern multi-core processors, it's now feasible to simulate and evaluate various designs and parameter combinations concurrently.

The ideal solution would be an open source Python optimization library that is capable of performing parallel evaluations and accommodating both discrete and continuous parameters, potentially including support for constraints, multi-objective, and quality diversity optimization approaches.

The European Space Agency (ESA) annually hosts an optimization competition. A particular optimization library excelled above the rest, which can be seen here: https://optimise.esa.int/user/867404f708354718b547739c784da79c . Despite its different application area, the features that contributed to its success are exactly what's needed for circuit design optimization.

As the creator of fcmaes (https://github.com/dietmarwo/fast-cma-es), I am exploring new areas where my library could be applied. My current interest is to develop a tutorial incorporating PySpice. However, this requires a PySpice sample that defines an objective function to accept input parameters, carry out a simulation, and return the results and possibly constraint values.

There are precedents in other domains, such as fluid dynamics, where objective functions for simulation-based optimization already exist. For example, take a look at https://github.com/AlgTUDelft/ExpensiveOptimBenchmark/blob/master/expensiveoptimbenchmark/problems/DockerCFDBenchmark.py. In my tutorial at https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/FluidDynamics.adoc, I demonstrate the application of fcmaes for parallel optimization in optimizing such designs.

I would like to hear your thoughts on this and whether it would be feasible to provide one or more meaningful example objective functions suitable for optmization. We could start with a small one.

Just to show you how this could look like I modified one of your examples, defined the resistor values
as decision variables and defined as objective the "distance" to the example node voltages.
Of course this makes not much sense, but what you can see is how easy it is to utilize parallel
PySpice simulation - it is just the "workers=16" definition. Of course fcmaes provides many more
optmization algorithms. Parallel Python exection works better on Linux, but on Windows there is
https://docs.microsoft.com/en-us/windows/wsl providing the same performance.

from PySpice import Circuit, Simulator
from PySpice.Unit import *

import numpy as np

def node_values(X):
    circuit = Circuit('Resistor Bridge')    
    circuit.V('input', 1, circuit.gnd, 10@u_V)
    circuit.R(1, 1, 2, X[0]@u_kΩ)
    circuit.R(2, 1, 3,  X[1]@u_kΩ)
    circuit.R(3, 2, circuit.gnd,  X[2]@u_kΩ)
    circuit.R(4, 3, circuit.gnd,  X[3]@u_kΩ)
    circuit.R(5, 3, 2, X[4]@u_kΩ)    
    simulator = Simulator.factory()
    simulation = simulator.simulation(circuit, temperature=25, nominal_temperature=25)
    analysis = simulation.operating_point()
    return np.array([float(node) for node in analysis.nodes.values()])

from fcmaes.optimizer import wrapper
from fcmaes import de
from scipy.optimize import Bounds
from loguru import logger
logger.remove()
logger.add(sys.stdout, format="{time:HH:mm:ss.SS} | {level} | {message}", level="INFO")
#logger.add("log_{time}.txt", format="{time:HH:mm:ss.SS} | {level} | {message}", level="INFO")

def optimize():
    
    target = np.array([6,4,10])
    bounds = Bounds([0.1]*5, [5]*5)

    def fitness(X):
        vals = node_values(X)
        diff = vals-target
        return np.dot(diff, diff)
    
    ret = de.minimize(wrapper(fitness), bounds=bounds, workers=16,
                      popsize=32, max_evaluations=50000, stop_fitness=1E-6)    

if __name__ == '__main__':
    optimize()

Best regards, Dietmar

[benedictjones]

This is absolutely no reason why you couldn't do this. Indeed, in the course of my PhD research I used PySpice to simulate random networks which I then used for Unconventional Computing, this was called Evolution in-Materio [1] (similar to Physical Reservoir Computing).

I was optimising my conductive network to map my inputs to outputs and enable classification. But I was always interested in the possibility of the auto-design/tuning of the conductive network itself. Similar work to this effect does seem to have been considered [2].

Your fcmaes package seems to be able to use the ask/tell structure, meaning it can integrate with such non-standard problems.
In my experience, it seems to work well will python's multiprocessing, although I have read some people express concerns about more lower level (i.e., NGSpice based) multiprocessing.

[1] B. JONES, ‘Harnessing Evolution in-Materio as an Unconventional Computing Resource’, Doctoral, Durham University, 2023. Available: http://etheses.dur.ac.uk/15119/
[2] X. Xia, Y. Li, W. Ying, and L. Chen, ‘Automated Design Approach for Analog Circuit Using Genetic Algorithm’, in Computational Science – ICCS 2007, https://doi.org/10.1007/978-3-540-72590-9_168

[dietmarwo]

Thks to your encouraging answer. I will check the references. Regarding multiprocessing: Initially I was interested in space flight related problems like https://github.com/esa/SpOC2 . ESA developed their own optimization library https://github.com/esa/pygmo2 . Pygmos parallelism utilizes C++ multithreading, but Python's multiprocessing is much better in isolating parallel simulation threads, which makes it ideal for parallel optimization in the context of simulation libraries. On a modern 16 core CPU a speed factor of 16-20 can be achieved when utilizing 32 parallel threads. I tested that already for

• https://qiskit.org/ for quantum simulations,
• https://www.openfoam.com/ for fluid dynamics,
• https://github.com/esa/pykep for space flight trajectories,
• https://github.com/oemof/tespy for energy modeling, and for
• https://github.com/StochSS/GillesPy2 for biochemical reactions.
  and finally for PySpice.