Improving AI Tool Use with Recurrent Loops

# Illustrative sketch (not from the paper)
import torch
import torch.nn as nn
import torch.nn.functional as F

class SharedTransformerBlock(nn.Module):
    def __init__(self, d_model):
        super().__init__()
        self.attn = nn.MultiheadAttention(d_model, num_heads=8)
        self.ff = nn.Sequential(nn.Linear(d_model, d_model * 4), nn.GELU(), nn.Linear(d_model * 4, d_model))
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
    def forward(self, x):
        # self‑attention
        attn_out, _ = self.attn(x, x, x)
        x = self.norm1(x + attn_out)
        # feed‑forward
        ff_out = self.ff(x)
        return self.norm2(x + ff_out)

class HaltingPolicy(nn.Module):
    def __init__(self, d_model):
        super().__init__()
        self.proj = nn.Linear(d_model, 1)
    def forward(self, hidden):
        # per‑token confidence → sigmoid probability
        return torch.sigmoid(self.proj(hidden.mean(dim=0)))

class LoopedModel(nn.Module):
    def __init__(self, shared_block, halting, max_iter=5, thresh=0.9):
        super().__init__()
        self.shared = shared_block
        self.halting = halting
        self.max_iter = max_iter
        self.thresh = thresh
    def forward(self, x):
        hidden = x
        for i in range(self.max_iter):
            hidden = self.shared(hidden)                     # recurrent refinement
            halt_prob = self.halting(hidden)                # Ouro‑style exit gate
            if halt_prob.item() > self.thresh:
                break                                        # adaptive stopping
        return hidden, i+1                                 # final representation and used iterations

// Illustrative sketch (not from the paper)
const tf = require('@tensorflow/tfjs-node');

function sharedTransformerBlock(dModel) {
  const attn = tf.layers.multiHeadAttention({numHeads: 8, keyDim: dModel / 8});
  const ff = tf.sequential();
  ff.add(tf.layers.dense({units: dModel * 4, activation: 'gelu'}));
  ff.add(tf.layers.dense({units: dModel}));
  const norm1 = tf.layers.layerNormalization();
  const norm2 = tf.layers.layerNormalization();
  return (x) => {
    const attnOut = attn.apply([x, x, x]);
    const x1 = norm1.apply(tf.add(x, attnOut));
    const ffOut = ff.apply(x1);
    return norm2.apply(tf.add(x1, ffOut));
  };
}

function haltingPolicy(dModel) {
  const proj = tf.layers.dense({units: 1});
  return (hidden) => {
    // average over sequence dimension, then sigmoid
    const avg = hidden.mean(0);
    return tf.sigmoid(proj.apply(avg));
  };
}

function LoopedModel(sharedBlock, halting, maxIter = 5, thresh = 0.9) {
  return async (x) => {
    let hidden = x;
    let used = 0;
    for (let i = 0; i < maxIter; i++) {
      hidden = sharedBlock(hidden);               // recurrent refinement
      const haltProb = (await halting(hidden).data())[0]; // confidence
      used = i + 1;
      if (haltProb > thresh) break;               // adaptive exit
    }
    return {output: hidden, iterations: used};
  };
}

// Example usage (placeholder tensors)
const dModel = 256;
const shared = sharedTransformerBlock(dModel);
const halt = haltingPolicy(dModel);
const model = LoopedModel(shared, halt);
// const input = tf.randomNormal([seqLen, dModel]);
// model(input).then(res => console.log(res.iterations));