Optimizing Model Capacity in Self-Refinement Pipelines

# Illustrative sketch (not from the paper)
import torch

class DummyModel(torch.nn.Module):
    def __init__(self, size):
        super().__init__()
        self.size = size  # model capacity identifier (e.g., 0.6B, 32B)
        self.linear = torch.nn.Linear(10, 10)
    def forward(self, x):
        return self.linear(x)

def run_stage(model, inp):
    # Simulate generation / critique / refinement
    return model(inp)

def self_refine_pipeline(gen_size, crit_size, ref_size, use_critic=True):
    gen = DummyModel(gen_size)
    crit = DummyModel(crit_size) if use_critic else None
    ref = DummyModel(ref_size)
    x = torch.randn(1, 10)
    gen_out = run_stage(gen, x)
    if use_critic:
        feedback = run_stage(crit, gen_out)
        # Placeholder: combine generator output with critic feedback
        ref_input = gen_out + feedback
    else:
        # No‑critique baseline: refiner sees raw generator output
        ref_input = gen_out
    refined = run_stage(ref, ref_input)
    return refined

def sweep(stage, size_list, fixed_cfg):
    """Vary one stage's size while keeping others fixed.
    stage: 'gen_size', 'crit_size', or 'ref_size'
    size_list: list of capacities to test
    fixed_cfg: dict with the other two sizes and use_critic flag
    """
    results = {}
    for sz in size_list:
        cfg = fixed_cfg.copy()
        cfg[stage] = sz
        out = self_refine_pipeline(
            cfg.get('gen_size'), cfg.get('crit_size'), cfg.get('ref_size'), cfg.get('use_critic', True)
        )
        # Use a simple scalar metric as a placeholder (e.g., mean activation)
        results[sz] = out.mean().item()
    return results

# Example: generator sweep (critic and refiner fixed)
gen_sizes = [0.6, 1.0, 2.0, 32]  # illustrative identifiers for model size
fixed_cfg = {'crit_size': 0.6, 'ref_size': 2.0, 'use_critic': True}
print(sweep('gen_size', gen_sizes, fixed_cfg))

// Illustrative sketch (not from the paper)
const torch = require('torch-js'); // placeholder for tensor ops

class DummyModel {
  constructor(size) {
    this.size = size; // capacity identifier (e.g., 0.6B, 32B)
    // Simple linear transformation as a stand‑in for a real LLM
    this.weight = torch.randn([10, 10]);
    this.bias = torch.randn([10]);
  }
  forward(x) {
    return torch.add(torch.matmul(x, this.weight), this.bias);
  }
}

function runStage(model, inp) {
  // Simulate generation / critique / refinement
  return model.forward(inp);
}

function selfRefinePipeline(genSize, critSize, refSize, useCritic = true) {
  const gen = new DummyModel(genSize);
  const crit = useCritic ? new DummyModel(critSize) : null;
  const ref = new DummyModel(refSize);
  const x = torch.randn([1, 10]);
  const genOut = runStage(gen, x);
  let refInput;
  if (useCritic) {
    const feedback = runStage(crit, genOut);
    // Placeholder combination of generator output and critic feedback
    refInput = torch.add(genOut, feedback);
  } else {
    // No‑critique baseline: refiner receives raw generator output
    refInput = genOut;
  }
  const refined = runStage(ref, refInput);
  return refined;
}

function sweep(stage, sizeList, fixedCfg) {
  // Vary one stage's size while keeping others fixed
  const results = {};
  for (const sz of sizeList) {
    const cfg = { ...fixedCfg, [stage]: sz };
    const out = selfRefinePipeline(
      cfg.genSize,
      cfg.critSize,
      cfg.refSize,
      cfg.useCritic !== undefined ? cfg.useCritic : true
    );
    // Simple scalar metric as a placeholder (mean of tensor values)
    results[sz] = out.mean().item();
  }
  return results;
}

// Example: critic sweep (generator and refiner fixed)
const critSizes = [0.6, 1.0, 2.0, 32]; // illustrative identifiers for model size
const fixedCfg = { genSize: 2.0, refSize: 2.0, useCritic: true };
console.log(sweep('critSize', critSizes, fixedCfg));