optimizer

Optimizer

What this is

A black-box optimization framework. You give it:

• A set of parameters with bounds (e.g. transistor widths, bias currents, resistor values)
• An evaluation function that takes parameters and returns performance metrics
• An objective that combines metrics into a single scalar to minimize

The optimizer iteratively picks parameter values, evaluates them, and converges toward the optimum. It treats the evaluation as a black box — it doesn't need to know whether you're running Spectre, Maestro, a Python model, or anything else.

When to use

• Circuit sizing — find W/L, bias currents, passive values that meet gain/BW/noise/power specs
• Design space exploration — sweep a high-dimensional parameter space that's too large for manual tuning or parametric sweeps
• Multi-objective tradeoffs — minimize power-delay product, noise-power FOM, etc.
• Any expensive black-box function — the evaluation can be slow (seconds to minutes per point); TuRBO is sample-efficient

When NOT to use

• Single-variable sweep — just use a parametric sweep in Maestro or a for-loop
• Analytical solution exists — if you can derive the optimum, don't search for it
• < 5 evaluations budget — TuRBO needs at least 2 * n_params initial samples

Algorithm choice

Situation	Algorithm	Why
≤ 3 params, smooth	scipy.optimize.minimize	Fast, no GP overhead
3–20 params, noisy/expensive	TuRBO (turbo.Turbo1)	Sample-efficient Bayesian optimization with trust regions
> 20 params	Consider random search + refinement	GP doesn't scale well beyond ~20D

Prerequisites

• For TuRBO: pip install torch gpytorch and local TuRBO install (pip install -e TuRBO/)
  • TuRBO (Trust Region Bayesian Optimization) comes from uber-research/TuRBO
• For scipy: included in standard Python scientific stack

Core pattern

import numpy as np
from turbo import Turbo1

# 1. Define parameters and bounds
PARAMS = ["W_tail", "W_inp", "R_load"]
LB = np.array([0.5, 0.5, 100.])
UB = np.array([10., 10., 5000.])

# 2. Objective: params → scalar (minimize)
def objective(x):
    try:
        result = evaluate(x, PARAMS)
    except Exception:
        return 1e6                     # penalty on failure, never nan/inf
    return compute_metric(result)

# 3. Run
turbo = Turbo1(f=objective, lb=LB, ub=UB,
               n_init=2*len(LB), max_evals=100, batch_size=1)
turbo.optimize()
best = turbo.X[turbo.fX.argmin()]