AdaSR: Adaptive Streaming Reasoning with Hierarchical Relative Policy Optimization
Abstract: Large reasoning models typically follow a read-then-think paradigm: they observe the complete input, reason over a static context, and then produce the answer. Yet many real-world scenarios are inherently dynamic, such as audio and video stream, where information arrives as a continuous stream and models must reason, update, and respond under partial observations. Recent streaming reasoning methods allow models to think while reading, but they largely rely on supervised imitation of pre-constructed trajectories, which limits their flexibility. In this paper, we propose AdaSR, an adaptive streaming reasoning framework that enables models to reason during input streaming and perform final deliberation once the stream is complete, learning when to think, and how much computation to allocate across different stages. To optimize this hierarchical reasoning process, we introduce Hierarchical Relative Policy Optimization (HRPO), which decomposes policy optimization into streaming reasoning and deep reasoning phases, providing more fine-grained advantage assignment instead of uniformly distributing a single sequence-level advantage over all tokens. HRPO integrates format, accuracy, and adaptive thinking rewards to enforce valid reasoning protocols, preserve final task performance, and encourage latency-aware computation allocation. Experiments show that AdaSR achieves a better balance among reasoning accuracy, computational efficiency, and streaming latency compared with supervised fine-tuning baseline. We release our code at https://github.com/EIT-NLP/StreamingLLM/tree/main/AdaSR.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
Explaining โAdaSR: Adaptive Streaming Reasoning with Hierarchical Relative Policy Optimizationโ
1) What is this paper about?
This paper is about teaching AI models how to โthink while readingโ instead of waiting until theyโve read everything. In the real world, information often arrives bit by bitโlike hearing a sentence at a time, watching a video frame by frame, or getting sensor updates over time. The authors present a new method called AdaSR that helps AI decide when to think, when to wait, and how much โbrainpowerโ to use at each moment as information streams in.
2) What questions are the researchers trying to answer?
The paper explores simple but important questions:
- How can an AI reason as it reads, instead of waiting until the end?
- How can it decide whether to think now, think later, or skip thinking for a moment?
- How can it split its effort wisely between quick, ongoing thoughts and a final, deeper review at the end?
- How can we reward the AI fairly so it gets credit for helpful early thoughts without encouraging wasteful overthinking?
3) How did they do it? (Methods in simple terms)
Think of a model like a student listening to a lecture that comes one sentence at a time. The student can:
- Jot down a quick note after each sentence (streaming reasoning).
- Do a final, careful summary after the lecture ends (deep reasoning).
The challenge is giving fair credit. If the final answer is correct, should the student get credit for every note they took? What if some notes were unnecessary? The paper introduces two main ideas:
- Two stages of thinking
- Streaming stage: quick thoughts as information arrives.
- Deep stage: a final, more careful round of thinking after everything is known.
- A smarter way to assign credit (HRPO)
- In many previous methods, the model gets one big reward at the end, and that reward is spread evenly across all the words it wrote. Thatโs like giving a sports team the same praise for every minute of the game, even if the winning play happened at the end.
- The authors propose HRPO (Hierarchical Relative Policy Optimization), which gives credit separately to the two stages:
- Credit for helpful quick thoughts (streaming).
- Credit for the final, careful reasoning (deep).
- Overall credit for the final answer being correct.
- This helps the model learn which parts of its thinking were actually useful.
They also shape the rewards to guide behavior:
- Format reward: Make sure the model follows the rules (e.g., clearly ends each short thought and the final reasoning).
- Accuracy reward: Reward correct answers.
- Adaptive thinking reward: Encourage using only as many words (tokens) as neededโdonโt be too wordy, but donโt be too brief either. It gently prefers doing more thinking during streaming (which can overlap with reading) and keeping the final stage short (which affects how long you wait for the final answer).
Finally, they built all this into an efficient system so it can run fast in practice using modern inference engines.
4) What did they find, and why does it matter?
Main takeaways:
- Better accuracy with less waiting: The new method, AdaSR with HRPO, often gets more answers right than older approaches and reduces the time users have to wait for the final answer. It does this by moving some thinking into the streaming stage and keeping the final stage shorter.
- Smarter use of effort: Compared to methods that imitate fixed examples, AdaSR learns to think more when it helps and skip when it doesnโt. It doesnโt just produce longer explanationsโit produces more useful ones.
- Works across tasks and sizes: They tested on math, science/medical question answering, and logic tasks using different model sizes. The improvements held up, including on datasets that were different from the training data.
- Practical speedups: With a fast backend (vLLM), streaming reasoning cut visible latency (the time users wait) by over 8ร compared to the traditional โread-then-thinkโ setup.
Why it matters:
- Many real-world systems (voice assistants, live translation, video analysis, robots, and sensors) donโt get all the information at once. Teaching models to reason as they read can make them more responsive and efficient, which is better for user experience and real-time applications.
5) Whatโs the impact and what could come next?
This work shows that โthinking while readingโ isnโt just a neat trickโitโs a different kind of problem that needs smarter training and fairer credit assignment. The approach can:
- Make AI assistants feel snappier and more helpful in real-time situations.
- Reduce unnecessary computation, which can save time and energy.
- Lead to safer and more reliable behavior by encouraging the model to reason at the right times.
For future work, the authors note that they focused on text with clear right-or-wrong answers. Next steps include applying these ideas to streaming audio, video, and interactive tasks where rewards are more complex and the inputs are multi-modal.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a concise, actionable list of what remains missing, uncertain, or unexplored in the paper.
- Modalities and tasks: The framework is only validated on text streams with verifiable final answers; it does not address audio/video streams, multimodal inputs, or open-ended/subjective tasks where final correctness is not binary or easily computable.
- External validity: Evaluation is limited to Qwen3-1.7B/4B on a small set of math/QA/logic datasets; it remains unclear how AdaSR/HRPO perform across diverse model families (e.g., Llama, Gemma, Mistral), larger scales, different languages, or domains like software debugging and real-time planning.
- Streaming segmentation: Inputs are segmented into sentences; the sensitivity of results to segmentation policy (chunk size, punctuation errors, noisy ASR segmentation, variable input rates) and to non-sentential streaming (token- or phrase-level chunks) is not explored.
- Latency realism: Latency is measured under simulated streaming (150 wpm) and token counts; effects of deployment factors (network jitter, variable input cadence, strict real-time deadlines, energy/GPU-time per token) are not quantified.
- Reward design robustness: The adaptive thinking reward penalizes length with gates tied to correctness/format; risks of reward hacking, over-optimization to length proxies, and robustness to noisy labels or partial credit tasks are unstudied.
- Generalization to non-verifiable objectives: The approach relies on accuracy rewards; how to extend HRPO to tasks without ground-truth answers (e.g., summarization, dialogue, creative writing) using preference models or human feedback remains open.
- Phase boundary assumptions: The deep-reasoning phase always starts after the final input segment; learning to trigger deep reasoning earlier (or produce final answers mid-stream) and dynamically choosing phase boundaries is not investigated.
- Hierarchical granularity: Only a two-stage hierarchy (streaming vs deep) is considered; whether finer or task-adaptive hierarchies (e.g., multi-stage streaming, sub-phases within deep reasoning) can improve credit assignment remains unknown.
- Theoretical guarantees: HRPOโs bias/variance properties, convergence behavior, and theoretical relation to standard policy gradient under hierarchical credit assignment are not analyzed beyond empirical results.
- Hyperparameter sensitivity: The paper references appendix analyses but lacks systematic, main-text exploration of sensitivity to ฮป (localโglobal mixing), ฮฒ (length reward weight), ฯ and ฮฑ (latency shaping), group size G, PPO clip ฮต, and KL ฮฒ; automated scheduling or meta-learning of these is not addressed.
- Stability and sample efficiency: The impact of HRPO on training stability, variance, and sample efficiency versus GRPO (especially under sparse rewards or small G) is not quantified; ablations on group size and rollout count are missing.
- Memory and compute overhead: The cost of storing and backpropagating through all streaming thoughts (RโโฆR_T) is not reported; memory scaling with long streams and the effect on KV-cache reuse or GPU footprint under vLLM are not measured.
- Streaming position encoding portability: The method relies on custom position IDs and attention masks; portability to different positional schemes (RoPE, ALiBi) and to other serving stacks beyond vLLM needs validation.
- Baselines on adaptive compute: Comparisons omit alternative adaptive inference methods (e.g., early-exit classifiers, test-time compute allocation, dynamic halting, self-consistency pruning); it is unclear how AdaSR fares against these.
- Failure analyses: When HRPO-sentence/token variants degrade accuracy or over-compress reasoning, qualitative analyses of failure modes are not provided; criteria for choosing granularity per task are not established.
- Robustness to streaming noise: The system is not tested under noisy or adversarial streams (ASR errors, reordering, missing segments, contradictions); robustness of streaming decisions and final accuracy under such conditions is unknown.
- Memory management of thoughts: The deep phase consumes all prior streaming thoughts; mechanisms to compress, prune, or retrieve only relevant thoughtsโand the effect on accuracy and latencyโare not explored.
- Safety and user experience: If intermediate thoughts are surfaced or logged, implications for privacy, premature conclusions, or misleading partial outputs are not studied; strategies for safeguarding early reasoning are absent.
- Budgeted inference: The framework optimizes token-length proxies but does not enforce hard latency/compute budgets or deadlines; extending HRPO to constrained optimization (e.g., knapsack-like budgets per query) remains open.
- Multi-task reward blending: Advantage composition is per-level but not per-task; how to balance competing objectives (accuracy vs latency) across heterogeneous tasks or user personas is not resolved.
- OOD breadth: OOD tests (GSM-Infinite, LogicNLI) are narrow; broader distribution shifts (long-context narrative QA, domain shift in biomedical/coding, multilingual streams) are not evaluated.
- Token-level credit signals: Only format-related token-level credit is attempted; methods to derive token-aligned semantic credit (e.g., via temporal-difference critics, hindsight credit assignment) are not explored.
- Integration with value functions: HRPO removes value models like GRPO; whether adding lightweight critics for phase-local baselines can reduce variance or improve credit assignment is an open direction.
- Reward latency weighting: The latency-aware reward assumes uniform per-token cost; accounting for growing KV-cache, heterogeneous hardware, or batching effects could alter optimal compute allocation.
- Incremental output tasks: Tasks requiring external, incremental outputs (e.g., simultaneous translation, streaming captioning) are not tested; how AdaSR handles emitting partial user-facing outputs (not just internal thoughts) is unclear.
- Curriculum and exploration: No curriculum or exploration strategies tailored to streaming (e.g., curriculum over stream length or chunk variability) are studied; entropy schedules and their effect on adaptivity are underexplored.
- Privacy and data retention: The framework accumulates streaming thoughts; policies for retention, truncation, or anonymization (especially with sensitive streams) are not discussed.
Practical Applications
Practical Applications of AdaSR (Adaptive Streaming Reasoning with HRPO)
AdaSR enables LLMs to โthink while readingโ streaming inputs and to allocate computation between an intermediate (streaming) phase and a final (deep) phase using a stage-aware reinforcement learning algorithm (HRPO). Below are actionable, real-world applications derived from the paperโs findings, methods, and innovations.
Immediate Applications
These can be built now with text or transcript streams, existing LLMs, and a vLLM-compatible serving stack.
- Real-time customer support and contact-center agent assist
- Sector: Software, customer service
- What: As a customer speaks or messages arrive, the system reasons incrementally (e.g., infers intent, retrieves articles) and provides immediate suggestions; it performs a brief final deliberation to consolidate solutions at turn end.
- Tools/products/workflows:
- Integrate ASR โ text stream โ AdaSR backend (vLLM).
- Use HRPO-trained policies to decide โthink vs skip,โ keep deep-phase short to minimize on-call latency.
- Add observability: metrics for streaming vs deep-phase token budgets, latency, and accuracy.
- Assumptions/dependencies:
- Reliable ASR for speech; robust segmentation into sentences/clauses.
- Reward design for training may rely on verifiable resolution outcomes (ticket solved, QA accuracy) or proxy metrics.
- Simultaneous speech translation and live interpretation assist
- Sector: Language services, media
- What: While listening to input, the model generates incremental translations and clarifications; deep-phase refines phrasing at segment boundaries.
- Tools/products/workflows:
- Pipeline: ASR โ sentence/phrase segmentation โ AdaSR translation model with latency-aware reward (adjust ฮฑ, ฯ to reflect latency targets).
- Deploy on vLLM for low-latency streaming.
- Assumptions/dependencies:
- Currently text-stream in/out (audio handled by ASR front-end).
- Data and reward signals for translation quality and latency.
- Meeting copilots (live summaries, action items, follow-ups)
- Sector: Productivity, enterprise SaaS
- What: Generate incremental topic summaries and action-item candidates during the meeting; finalize a concise summary at meeting end.
- Tools/products/workflows:
- Real-time transcript feed โ AdaSR notes/extracts โ final synthesis.
- HRPO rewards tuned to suppress redundant verbosity mid-call, preserve concise final output.
- Assumptions/dependencies:
- High-quality transcript; tasks with partial verifiability (e.g., correct extraction of names, dates).
- IDE/code-assistant โtype-aheadโ reasoning
- Sector: Software engineering, developer tools
- What: As developers type, the assistant reasons about possible errors/tests and suggests minimal fixes; performs a quick deep-phase check on save or test run.
- Tools/products/workflows:
- Streaming diffs from the editor โ AdaSR code reasoner.
- Token budget knobs to keep suggestions sub-100 ms; deep-phase constraints for tight edit loops.
- Assumptions/dependencies:
- Verifiable tasks (unit-test pass/fail, lint rules) for RL signals.
- IDE integration and safety filters.
- Live content moderation and trust & safety triage
- Sector: Online platforms, community management
- What: Streamed chat/comments are triaged with early warnings (e.g., probable policy violation); final deep-phase aggregates context for higher-confidence decisions or escalation.
- Tools/products/workflows:
- Moderation labels โ HRPO training with format and length rewards to limit latency.
- โSkipโ when context is insufficient; only deep-think when a threshold is crossed.
- Assumptions/dependencies:
- High-quality labels; fairness and bias checks.
- Human-in-the-loop for enforcement in ambiguous cases.
- Streaming news and market intelligence alerts
- Sector: Finance, enterprise risk
- What: As newswire/filings stream, the model flags potential risk themes early; consolidates relevant details when more evidence accumulates.
- Tools/products/workflows:
- Topic/risk classifier with AdaSR; deep-phase only when a plausible risk pattern emerges.
- Latency-aware reward to prioritize early-but-cautious alerts.
- Assumptions/dependencies:
- Proxy rewards (click-through, analyst confirmation) when ground truth is delayed.
- Compliance guardrails and audit trails.
- On-device/edge pre-processing with cloud refinement
- Sector: IoT, mobile/edge AI
- What: Lightweight streaming reasoning at the edge (filtering, early classification) with a small deep-phase offloaded to the cloud when needed.
- Tools/products/workflows:
- Two-tier deployment: streaming-phase on-device, deep-phase in cloud; token budgets enforced per tier.
- vLLM or equivalent for cloud; compact local model for edge.
- Assumptions/dependencies:
- Stable connectivity for deep-phase offload; privacy/security constraints.
- Task-specific rewards for edge objectives (e.g., bandwidth saved, false-alarm cost).
- Live clinical scribe and telehealth assistant (non-diagnostic)
- Sector: Healthcare (administrative support)
- What: Draft notes, highlight problems/medications during the conversation; perform a final pass to structure SOAP notes at session end.
- Tools/products/workflows:
- Transcript โ AdaSR โ incremental notes + final structured export to EHR template.
- Rewards prioritize structured formats and brevity mid-call.
- Assumptions/dependencies:
- Not for diagnosis; requires strict PHI handling, auditability, clinician oversight.
- Verifiable formatting/coverage metrics for RL shaping.
- Education and tutoring assistants
- Sector: Education/EdTech
- What: Provide step-wise hints as a learner works through problems; finalize solution explanation after full problem is read.
- Tools/products/workflows:
- Use datasets with verifiable answers (e.g., GSM-like) for training.
- Limit deep-phase token use to maintain interactivity.
- Assumptions/dependencies:
- Careful reward design to avoid over-revealing answers; pedagogy-aligned hinting.
- Incident/operations triage from streaming logs
- Sector: DevOps, SRE, IT operations
- What: Early detection of anomalies from log streams with incremental reasoning; final consolidation when sufficient evidence arrives.
- Tools/products/workflows:
- Log ingestion โ AdaSR anomaly reasoner; skip routine messages, think on anomalies.
- Deep-phase generates incident summaries/playbooks.
- Assumptions/dependencies:
- Labels or proxy rewards (MTTR, false-positive cost).
- Developer/infra productization
- Sector: MLOps/LLMops
- What: Ship an โAdaptive Streaming Reasoner SDKโ with:
- vLLM-compatible streaming position encoding and masks.
- HRPO training scripts and reward templates (format, accuracy, length).
- Budget controller to set max streaming/deep tokens per request.
- Assumptions/dependencies:
- Base model quality sufficient for target tasks; GPU resources for RL.
Long-Term Applications
These require multimodal support, richer reward signals, regulatory approvals, or further scaling.
- End-to-end audio/video streaming reasoning
- Sector: Media, security, sports, retail
- What: Directly reason over continuous audio/video (e.g., highlight plays, detect safety events) with incremental updates and final summaries.
- Tools/products/workflows:
- Modality-specific rollout engines; HRPO extensions with multimodal rewards.
- Assumptions/dependencies:
- Robust multimodal encoders; ground-truth labels for streaming events; higher compute.
- Safety-critical robotics and autonomous systems
- Sector: Robotics, automotive, industrial automation
- What: Allocate compute to early hazard assessment, then deep-phase consolidation for path planningโbalancing speed and accuracy.
- Tools/products/workflows:
- Hybrid stack: classical perception + AdaSR-high-level reasoning.
- Fail-safes and verification for temporal credit assignment.
- Assumptions/dependencies:
- Certification, redundancy, formal guarantees; rigorous offline/online evaluation.
- Continuous patient monitoring and early-warning systems
- Sector: Healthcare (clinical decision support)
- What: Streaming vitals and notes feed incremental risk assessment; deep-phase synthesizes multi-sensor trends for alerts.
- Tools/products/workflows:
- HRPO rewards reflecting clinical utility (sensitivity/specificity vs alarm fatigue).
- Assumptions/dependencies:
- Regulatory approval; clinical trials; explainability; data privacy.
- Multi-agent, interactive systems with partial observability
- Sector: Gaming, operations research, logistics
- What: Agents that adapt compute to evolving state (streaming reasoning while observing, deep-phase at critical decision points).
- Tools/products/workflows:
- Integration with environment simulators; reward designs for long-horizon outcomes.
- Assumptions/dependencies:
- Stable interfaces for streaming observations; domain-specific safety/ethics.
- Networked edgeโcloud compute orchestration
- Sector: Cloud/edge infrastructure
- What: System-level schedulers that dynamically allocate streaming vs deep-phase compute across nodes to meet latency SLAs.
- Tools/products/workflows:
- Serving layer integrates HRPO signals with cluster QoS policies.
- Assumptions/dependencies:
- Multi-tenant fairness; cost-aware scheduling; robust monitoring.
- Finance-grade surveillance and compliance copilot
- Sector: Finance, regtech
- What: Real-time surveillance reasoner that incrementally flags potential issues; deep-phase builds regulator-ready rationales.
- Tools/products/workflows:
- Audit trails capturing streaming and deep tokens; controls on token budgets by risk tier.
- Assumptions/dependencies:
- Human review; model risk management; explainability requirements.
- Policy and standards for streaming LLMs
- Sector: Public policy, standards bodies
- What: Benchmarks and compliance guidelines that account for latency-aware reasoning and temporal credit assignment.
- Tools/products/workflows:
- Open datasets and evaluation suites that report accuracy, streaming latency, deep-phase latency, and token budgets.
- Assumptions/dependencies:
- Community consensus on metrics; reproducible serving conditions.
- Energy-aware and sustainability-focused serving
- Sector: Energy/Green AI
- What: Dynamically reduce deep-phase compute to meet energy budgets during peak load; shift work into streaming when feasible.
- Tools/products/workflows:
- Energy-aware reward shaping; cluster controllers that tune token budgets by grid signals.
- Assumptions/dependencies:
- Accurate energy telemetry; acceptance of adaptive quality under constraints.
- Domain-adaptive RL pipelines for non-verifiable tasks
- Sector: Cross-industry
- What: Extend HRPO with preference learning or implicit feedback where exact answers are unavailable (e.g., summarization, creative tasks).
- Tools/products/workflows:
- Reward models from user ratings; bandit or preference-optimized HRPO variants.
- Assumptions/dependencies:
- Data collection pipelines; bias and safety mitigation.
- Hardware/accelerator co-design for streaming reasoning
- Sector: Semiconductors, systems
- What: Specialized kernels/memory layouts for streaming positional encodings and masks; token-level budget enforcement in hardware.
- Tools/products/workflows:
- Compiler/runtime support for dynamic masks; preemption for deep-phase bursts.
- Assumptions/dependencies:
- Vendor adoption; cost/benefit vs general-purpose hardware.
Cross-Cutting Assumptions and Dependencies
- Input form: Immediate deployments assume text streams (or speech with ASR). Multimodal audio/video needs new rollout engines and rewards.
- Rewards and ground truth: Accuracy reward works best when answers are verifiable; otherwise, use proxy signals (preferences, click-through, human ratings).
- Serving stack: vLLM (or equivalent) must support streaming position encodings and attention masks; throughput and latency gains depend on overlapping compute with input arrival.
- Model quality and safety: Base model competence, domain adaptation, and robust safety filters (especially for healthcare/finance) are essential.
- Compute and cost: HRPO training is more involved than SFT; monitoring and token-budget enforcement are needed to control inference cost.
- Governance: For regulated settings, maintain logs of streaming thoughts and final deliberation, enable human oversight, and ensure explainability.
These applications leverage AdaSRโs core strengths: deciding when to think vs skip under partial observations, allocating compute to meet latency/accuracy targets, and deploying efficiently via a vLLM-compatible streaming pipeline.
Glossary
- Accuracy reward: A terminal task signal that grants positive feedback when the final answer is correct. "The accuracy reward provides the terminal task signal:"
- AdaSR (Adaptive Streaming Reasoning): A framework that enables models to decide when and how much to think during streaming inputs and during final deliberation. "we propose AdaSR, an adaptive streaming reasoning framework that enables models to reason during input streaming"
- Adaptive thinking reward: A reward that shapes how much computation the model allocates by penalizing excessive token lengths while allowing necessary reasoning. "The adaptive thinking reward uses token length as a proxy for computation allocation."
- Chain-of-thought (CoT) reasoning: A method where models produce intermediate reasoning steps before giving the final answer. "often through chain-of-thought (CoT) reasoning"
- Cross-phase credit paradox: A misattribution issue where success in one phase wrongly boosts or suppresses contributions in another. "GRPO's uniform advantage assignment leads to a cross-phase credit paradox: deep-phase success can falsely amplify redundant streaming thoughts, while deep-phase inefficiency can unfairly suppress useful ones."
- Deep phase: The post-stream stage where the full context is integrated into a final, deliberative reasoning response. "The second factor is the deep phase, integrating and into the final response ."
- Format reward: A structural constraint ensuring outputs are parseable and adhere to required tokens (e.g., <EOT>, <EOR>). "The format reward makes rollouts parseable for HRPO."
- GDPO: A reinforcement learning variant noted for multi-reward normalization strategy used in advantage composition. "Following the multi-reward normalization observation in GDPO~\citep{liu2026gdpo}"
- Group Relative Policy Optimization (GRPO): An RL objective that computes sequence-level relative advantages within a sampled group, avoiding value models. "A natural starting point is Group Relative Policy Optimization (GRPO)~\citep{shao2024deepseekmath}"
- Group-relative normalization: Normalizing rewards relative to other samples within the same group to compute advantages. "HRPO keeps the group-relative normalization of GRPO"
- Hierarchical Advantage Assignment: A credit assignment approach that splits advantages across streaming-local, deep-local, and global levels. "Hierarchical Advantage Assignment"
- Hierarchical Relative Policy Optimization (HRPO): An RL method that decomposes policy optimization by assigning stage-aware advantages to streaming and deep phases. "we introduce Hierarchical Relative Policy Optimization (HRPO)"
- Importance ratio: The token-wise probability ratio between current and old policies used for off-policy correction and clipping. "the token-wise importance ratio is paired with a sequence-level advantage"
- KullbackโLeibler (KL) regularization: A penalty encouraging the updated policy to remain close to a reference policy. "with controlling the KL regularization strength."
- Latency-aware computation allocation: Rewarded behavior that balances where and how much reasoning occurs to reduce end-to-end delay. "and encourage latency-aware computation allocation."
- Pareto improvement: Simultaneous gains (e.g., higher accuracy and shorter outputs) without sacrificing other metrics. "This suggests that stronger base models can turn adaptive streaming reasoning into a Pareto improvement."
- Proximal Policy Optimization (PPO): A trust-region RL algorithm using clipped objective functions for stable policy updates. "In PPO~\citep{schulman2017proximal}, old-policy rollouts are reweighted token by token and clipped to stabilize updates"
- Read-then-think pattern: A baseline paradigm where models only start reasoning after seeing the entire input. "This paradigm follows a read then think pattern"
- Sequence-level advantage: A single advantage value applied uniformly across all tokens of a generated sequence. "uniformly distributing a single sequence-level advantage over all tokens."
- Streaming attention masks: Attention constraints that prevent the model from accessing future input during streaming generation. "Streaming attention masks prevent attending to future input during the streaming phase."
- Streaming position encoding: A positional scheme where input and reasoning tokens maintain separate positional indices during streaming. "Position IDs implement streaming position encoding---input tokens and reasoning tokens maintain independent positional indices"
- Streaming rollout: The inference/training procedure that decodes intermediate thoughts as input arrives and final thoughts after the stream ends. "we implement streaming rollout by extending the vLLM inference engine~\citep{kwon2023efficient}"
- Streaming thinking: A paradigm where the model reasons incrementally as the input stream unfolds. "streaming thinking ... lets reasoning unfold with the input stream"
- Success-conditioned trajectory-level efficiency reward: A global reward that promotes sufficient but not excessive reasoning after verifying format and correctness. "We therefore introduce a success-conditioned trajectory-level efficiency reward:"
- Temporal credit assignment: The challenge of attributing rewards to decisions made at different times (streaming vs. deep phase). "The central difficulty in streaming reasoning is temporal credit assignment"
- Test-time compute allocation: Deciding how much computation to expend during inference, depending on the inputโs difficulty and stage. "echoing broader efforts on adaptive computation and test-time compute allocation"
- Trust-region behavior: The stability property achieved by clipping updates so the new policy doesnโt deviate too far from the old one. "inherits PPO's trust-region behavior through the clipping threshold "
- vLLM inference engine: A high-throughput serving backend adapted here for streaming training and decoding. "we implement streaming rollout by extending the vLLM inference engine~\citep{kwon2023efficient}"
Collections
Sign up for free to add this paper to one or more collections.