Inexpensive label strategies from amortized optimization can reduce the computational cost of fitness evaluation in LLM-driven zeroth-order optimization loops.

Using amortized optimization-derived inexpensive label strategies as surrogate fitness evaluators within LLM-driven zeroth-order optimization (ZOO) loops reduces total computational cost (measured in FLOPs, wall-clock time, and API token expenditure) by at least 30% compared to full LLM-based fitness evaluation, while maintaining optimization performance within 10% of the full-evaluation baseline on standard benchmark tasks. Specifically: given a ZOO loop where an LLM scores candidate solutions at each iteration, a learned surrogate (amortized over prior evaluations) can substitute for the LLM on ≥50% of evaluations without statistically significant degradation in final solution quality.

Minimum Viable Test (MVT): Select 3 benchmark optimization tasks (prompt optimization, code synthesis, hyperparameter search). Implement a ZOO loop (e.g., CMA-ES or LLM-based evolutionary search) with two conditions: (A) full LLM fitness evaluation every iteration, (B) amortized surrogate (lightweight classifier/regressor trained on first N=100 LLM evaluations) used for 70% of subsequent evaluations with LLM called only for top-k candidates per round. Measure: solution quality, total LLM calls, wall-clock time, and API cost across 5 random seeds per condition. Full Validation: Extend to 5 tasks, 3 LLM scales (7B, 13B, 70B or API equivalents), 3 surrogate architectures (linear probe, small MLP, fine-tuned small LM), and ablate surrogate substitution rates (10%, 30%, 50%, 70%, 90%).

# Amortized Surrogate-Gated ZOO Loop
# Architecture: ZOO optimizer + LLM evaluator + surrogate model

class AmortizedZOOLoop:
    def __init__(self, llm_evaluator, surrogate_model, 
                 substitution_rate=0.7, warmup_budget=100):
        self.llm = llm_evaluator          # e.g., GPT-4o-mini or Llama-3-8B
        self.surrogate = surrogate_model  # e.g., MLP or DistilBERT regressor
        self.sub_rate = substitution_rate
        self.warmup = warmup_budget
        self.memory = []  # (candidate, llm_score) pairs
        self.is_amortized = False

    def evaluate(self, candidates: list[str]) -> list[float]:
        if len(self.memory) < self.warmup or not self.is_amortized:
            # Warmup phase: full LLM evaluation
            scores = [self.llm.score(c) for c in candidates]
            self.memory.extend(zip(candidates, scores))
            if len(self.memory) >= self.warmup:
                self._train_surrogate()
                self.is_amortized = True
            return scores
        else:
            return self._hybrid_evaluate(candidates)

    def _hybrid_evaluate(self, candidates):
        # Step 1: Get surrogate scores + uncertainty for all candidates
        surr_scores, uncertainties = self.surrogate.predict_with_uncertainty(
            [self._embed(c) for c in candidates]
        )
        # Step 2: Select which candidates need LLM evaluation
        # Policy: call LLM for top-k by uncertainty OR top-k by surrogate score
        n_llm_calls = max(1, int(len(candidates) * (1 - self.sub_rate)))
        llm_indices = self._select_llm_candidates(
            surr_scores, uncertainties, n_llm_calls
        )
        # Step 3: LLM evaluation for selected candidates
        final_scores = list(surr_scores)  # default to surrogate
        for idx in llm_indices:
            llm_score = self.llm.score(candidates[idx])
            final_scores[idx] = llm_score
            self.memory.append((candidates[idx], llm_score))
        # Step 4: Periodic surrogate retraining
        if len(self.memory) % 50 == 0:
            self._train_surrogate()
        return final_scores

    def _select_llm_candidates(self, scores, uncertainties, n):
        # Hybrid: 50% highest uncertainty, 50% highest surrogate score
        unc_top = set(np.argsort(uncertainties)[-n//2:])
        score_top = set(np.argsort(scores)[-(n - n//2):])
        return list(unc_top | score_top)

    def _train_surrogate(self):
        X = [self._embed(c) for c, _ in self.memory]
        y = [s for _, s in self.memory]
        self.surrogate.fit(X, y)

    def _embed(self, candidate: str) -> np.ndarray:
        # Use frozen LLM embeddings or TF-IDF as cheap features
        return self.llm.embed(candidate)  # cached, no generation cost

# ZOO Optimizer (e.g., CMA-ES variant for discrete text)
class TextZOOOptimizer:
    def __init__(self, evaluator: AmortizedZOOLoop, 
                 population_size=20, max_iters=200):
        self.evaluator = evaluator
        self.pop_size = population_size
        self.max_iters = max_iters

    def optimize(self, task_description: str) -> str:
        population = self._initialize_population(task_description)
        best_solution, best_score = None, -inf
        for iteration in range(self.max_iters):
            scores = self.evaluator.evaluate(population)
            best_idx = np.argmax(scores)
            if scores[best_idx] > best_score:
                best_score = scores[best_idx]
                best_solution = population[best_idx]
            # Generate next population via LLM mutation/crossover
            population = self._evolve(population, scores)
            # Logging
            log_iteration(iteration, scores, self.evaluator.memory)
        return best_solution

# Surrogate Model Options
class MLPSurrogate:
    # 2-layer MLP: input_dim -> 256 -> 128 -> 1
    # Trained with MSE loss + MC Dropout for uncertainty
    pass

class LinearSurrogate:
    # Ridge regression on LLM embeddings
    # Uncertainty via bootstrap ensemble (5 models)
    pass

class SmallLMSurrogate:
    # DistilBERT fine-tuned as regressor
    # Uncertainty via temperature scaling
    pass

# Experiment runner
def run_experiment(task, llm_size, surrogate_type, sub_rate, seed):
    set_seed(seed)
    llm = load_llm(llm_size)
    surrogate = surrogate_type()
    evaluator = AmortizedZOOLoop(llm, surrogate, 
                                  substitution_rate=sub_rate,
                                  warmup_budget=100)
    optimizer = TextZOOOptimizer(evaluator)
    result = optimizer.optimize(task.description)
    return {
        "quality": task.evaluate(result),
        "llm_calls": evaluator.llm_call_count,
        "total_cost_usd": evaluator.compute_cost(),
        "wall_time_s": elapsed_time()
    }