scaling-latent-reasoning

name	scaling-latent-reasoning
title	Scaling Latent Reasoning via Looped Language Models
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.25741
keywords	["Looped Models","Latent Reasoning","Test-time Scaling","Knowledge Manipulation"]
description	Scales reasoning depth through internal iteration rather than explicit generation. Ouro models perform repeated computation in latent space with entropy-regularized objectives enabling learned depth allocation. Smaller 1.4B model matches 12B standard models through improved knowledge manipulation.

Looped Language Models: Latent Reasoning Depth

Scaling language models conventionally increases size, consuming memory and compute. Looped Language Models (LoopLM) scale reasoning depth through internal iteration in latent space, enabling smaller models to perform like much larger ones.

The approach embeds reasoning into pre-training, eliminating dependence on test-time chain-of-thought.

Core Concept

Key innovation: models perform iterative computation in hidden representations rather than generating explicit reasoning:

• Latent space iteration: reasoning happens internally
• Learned depth allocation: models decide iteration count per problem
• Pre-training integration: no post-hoc prompting needed
• Efficiency: internal reasoning is less token-expensive than explicit CoT

Architecture Overview

• Standard transformer backbone with looping mechanism
• Recurrent computation block for latent iterations
• Entropy regularization for depth control
• Output head for final answer generation

Implementation Steps

Implement looped computation block that performs K iterations in latent space:

class LoopedComputationBlock(nn.Module):
    def __init__(self, hidden_dim=768, max_loops=4):
        super().__init__()
        self.hidden_dim = hidden_dim
        self.max_loops = max_loops

        # Iteration processing (same weights reused)
        self.loop_processor = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim * 2),
            nn.ReLU(),
            nn.Linear(hidden_dim * 2, hidden_dim)
        )

        # Depth prediction: how many iterations needed?
        self.depth_predictor = nn.Linear(hidden_dim, 1)

        # Entropy regularization for learning allocation
        self.entropy_reg = 0.1

    def ():
        
        current = hidden_state
        iteration_outputs = [current]

        
        depth_logit = .depth_predictor(hidden_state)
        depth_prob = torch.sigmoid(depth_logit).squeeze(-)

        
         .training:
            depth = torch.bernoulli(depth_prob * .max_loops).()
        :
            depth = (depth_prob * .max_loops).().()

        depth = torch.clamp(depth, , .max_loops)

        
         i  (.max_loops):
             i < depth.().item():
                
                current = .loop_processor(current)
                iteration_outputs.append(current)

                
                entropy = -torch.mean(
                    depth_prob * torch.log(depth_prob + ) +
                    ( - depth_prob) * torch.log( - depth_prob + )
                )
                .entropy_loss = -.entropy_reg * entropy

        
        output = iteration_outputs[-]

         return_depth:
             output, depth
         output