optimizer

分类: 内容与多媒体 | 上传者: Arcadia-1 | 下载: 0 | 版本: v1.0（最新）

使用 TuRBO 或 scipy 对设计参数进行黑盒优化。当用户想要优化、调整、调整大小、扫描或探索设计空间以满足规格时触发。这包括电路尺寸（W/L、偏置、无源器件）、寻找最佳工作点、最小化功率延迟或噪声功率权衡，或者需要搜索多个参数才能达到目标的任何任务。当用户说出“找到最佳尺寸”、“帮我调整这个”、“运行优化”、“什么值给我最好的 FOM”或“扫描这些参数以满足规格”等内容时也会触发。不要触发单变量参数扫描或分析计算。

更新日志: Source: GitHub https://github.com/Arcadia-1/virtuoso-bridge-lite

目录结构

当前层级: tree/main/skills/optimizer/

📄 SKILL.md 4.9 KB

SKILL.md

---
name: optimizer
description: "Black-box optimization of design parameters using TuRBO or scipy. TRIGGER when the user wants to optimize, tune, size, sweep, or explore a design space to meet specs. This includes circuit sizing (W/L, bias, passives), finding optimal operating points, minimizing power-delay or noise-power tradeoffs, or any task where multiple parameters need to be searched to hit a target. Also trigger when the user says things like 'find the best sizing', 'help me tune this', 'run an optimization', 'what values give me the best FOM', or 'sweep these parameters to meet spec'. Do NOT trigger for single-variable parametric sweeps or analytical calculations."
---

# 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](https://github.com/uber-research/TuRBO)
- For scipy: included in standard Python scientific stack

## Core pattern

```python
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()]
```

## Evaluation backends

The `evaluate()` function is the only part that changes between use cases:

**Spectre netlist** — parameterize a `.scs` template and run remotely:
```python
from virtuoso_bridge.spectre.runner import SpectreSimulator
sim = SpectreSimulator.from_env(work_dir="./opt", output_format="psfascii")

def evaluate(x, params):
    text = Path("tb_template.scs").read_text()
    for name, val in zip(params, x):
        text = text.replace(f"@@{name}@@", f"{val:.6g}")
    Path("opt/tb.scs").write_text(text)
    return sim.run_simulation(Path("opt/tb.scs"), {})
```

**Maestro** — set design variables and run an existing test via SKILL:
```python
from virtuoso_bridge import ramic_send

def evaluate(x, params):
    for name, val in zip(params, x):
        ramic_send(f'maeSetDesignVar("{name}" {val:.6g})')
    ramic_send('maeRunTest("myTest")')
    gain = float(ramic_send('maeGetTestResult("myTest" "gain_db")'))
    bw = float(ramic_send('maeGetTestResult("myTest" "bw_hz")'))
    return {"gain": gain, "bw": bw}
```

**Any Python callable**:
```python
def evaluate(x, params):
    return my_model.predict(dict(zip(params, x)))
```

## Objective design

Return a **scalar float**. Return `1e6` on failure — never `nan` or `inf`, because these break the GP surrogate model and cause the optimizer to diverge.

| Goal | Return |
|------|--------|
| Min power-delay | `power * delay` |
| Max gain-bandwidth | `-(gain_db + 20*log10(bw))` |
| With constraint | `obj + 1e3 * max(0, noise - spec)**2` |

## Related skills

- **spectre** — Spectre simulation runner, netlist syntax, result parsing
- **virtuoso** — Maestro setup, schematic editing, design variable management

登录后下载/点赞/收藏 ❤ 203 | ★ 0

optimizer

目录结构

SKILL.md

举报内容

提示