# iteration

Iteration is the repeated execution or application of operations or processes, including programming loops such as for, foreach, do, and while statements.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## ResearchFlow-Eval: Tracing the Execution Gap in End-to-End Multi-Claim Autoresearch

DevFeed: [ResearchFlow-Eval: Tracing the Execution Gap in End-to-End Multi-Claim Autoresearch](<https://devfeed.tech/articles/researchflow-eval-tracing-the-execution-gap-in-end-to-end-multi-claim-autoresearch-144962.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.18088>)

Author: Peng Jiang, Dongyang Li, Quanying Liu, Xiaoxuan Jia

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [hierarchical agent systems](<https://devfeed.tech/topics/hierarchical-agent-systems.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [DeepFact-Bench](<https://devfeed.tech/topics/deepfact-bench.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-harnesses](<https://devfeed.tech/tags/agent-harnesses.md>), [anchor](<https://devfeed.tech/tags/anchor.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [autoresearch](<https://devfeed.tech/tags/autoresearch.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [completion](<https://devfeed.tech/tags/completion.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [design](<https://devfeed.tech/tags/design.md>), [dimensions](<https://devfeed.tech/tags/dimensions.md>), [eval](<https://devfeed.tech/tags/eval.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [execution](<https://devfeed.tech/tags/execution.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [framework](<https://devfeed.tech/tags/framework.md>), [gap](<https://devfeed.tech/tags/gap.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [tracing](<https://devfeed.tech/tags/tracing.md>)

### AI overview

ResearchFlow-Eval assesses whether autoresearch systems can carry multiple interdependent claims through continuous research stages and revise experiments as evidence accumulates. It derives stage-specific rubrics from published anchor papers and scores work at both stage and claim levels. Across the evaluated general-purpose, skill-augmented, and research-orchestrated systems, experimental execution scored below design and planning. Systems often struggled to produce high-quality results that met claim requirements, and repeated attempts rarely improved scores. Skill augmentation and research-specific orchestration did not reliably raise performance. Results are averaged over two runs per system and scored by two LLM judges.

### Source excerpt

arXiv:2610.18088v3 Announce Type: replace-cross Abstract: Autoresearch systems increasingly undertake entire research projects. In practice, scientific research requires systems to pursue multiple interdependent claims through a continuous, multi-stage workflow and revise experiments as evidence accumulates. Existing evaluations of autoresearch systems, however, typically score isolated tasks or final artifacts, leaving these process-level capabilities largely unmeasured. We therefore introduce ResearchFlow-Eval, a fine-grained framework for assessing continuous scientific execution and iteration at both the stage and claim levels. Each evaluation is grounded in a published anchor paper, from which we derive stage-specific rubrics that decompose each research stage into dimensions and separately scored rubric items. Using these rubrics, we score each research stage and examine experimental execution in detail, focusing on multi-claim completion and revisions across attempts. We apply the evaluation framework to general-purpose agent harnesses, skill-augmented harnesses, and systems with research-specific orchestration. Averaged over two runs per system, each scored by two LLM judges, experimental execution lags behind design and planning for every evaluated system. Within execution, systems struggle to produce high-quality results and meet claim requirements, and repeated attempts rarely yield measurable improvements. Moreover, neither skill augmentation nor research-specific orchestration reliably yields higher scores. ResearchFlow-Eval thus extends autoresearch evaluation beyond isolated, single-objective runs to continuous workflows in which systems pursue multiple claims and refine their work across iterations.

## DDSL: Iterative Self-Labeling for Financial Market States

DevFeed: [DDSL: Iterative Self-Labeling for Financial Market States](<https://devfeed.tech/articles/ddsl-iterative-self-labeling-for-financial-market-states-141826.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22958>)

Author: Xianbin Gu, Qingyue Zhu, Yuhong Geng

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Ground truth / benchmark quality](<https://devfeed.tech/topics/ground-truth-benchmark-quality.md>), [Finance](<https://devfeed.tech/topics/finance.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [bull](<https://devfeed.tech/tags/bull.md>), [classifier](<https://devfeed.tech/tags/classifier.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [dynamic-programming](<https://devfeed.tech/tags/dynamic-programming.md>), [entropy](<https://devfeed.tech/tags/entropy.md>), [event](<https://devfeed.tech/tags/event.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [financial](<https://devfeed.tech/tags/financial.md>), [financial-market](<https://devfeed.tech/tags/financial-market.md>), [gru](<https://devfeed.tech/tags/gru.md>), [labeling](<https://devfeed.tech/tags/labeling.md>), [state](<https://devfeed.tech/tags/state.md>), [temporal](<https://devfeed.tech/tags/temporal.md>), [transformer](<https://devfeed.tech/tags/transformer.md>), [validation](<https://devfeed.tech/tags/validation.md>), [weight](<https://devfeed.tech/tags/weight.md>)

### AI overview

DDSL iteratively refines financial market-state labels by coupling a price- and grammar-guided Viterbi labeler with a Transformer classifier through model feedback. Its nine-state representation encodes current and future trends while retaining structured price emissions and temporal constraints. Across SSE50, CSI300, CSI500, and NASDAQ100, it raises held-out joint-state macro F1 by 78%-96% over single-pass dynamic-programming labeling; an independent GRU shows the same overall gain, with stable label entropy and class coverage. Learnability depends on iteration and feedback weight: gains diminish as label systems converge, while stronger feedback widens the Transformer-GRU performance gap. Greater learnability also accompanies declining segment-level price-feature separation after an initial improvement. Event-study validation is partial: refinement strengthens a conditional BEAR-to-BULL reversal signal on the three A-share datasets, but the effect has the opposite sign on NASDAQ100.

### Source excerpt

arXiv:2611.22958v1 Announce Type: new Abstract: Financial market states lack a unique ground truth and must therefore be constructed from price data. Conventional labeling methods typically define states independently of the downstream classifier, leaving unresolved whether the resulting labels can be recovered from information available at prediction time. We propose DDSL, an iterative self-labeling framework that couples a price- and grammar-guided Viterbi labeler with a Transformer classifier through model feedback. DDSL constructs a nine-state representation that jointly encodes current and future market trends while retaining structured price emissions and temporal constraints throughout refinement. Experiments on SSE50, CSI300, CSI500, and NASDAQ100 show that DDSL increases held-out joint-state macro F1 by 78%-96% over single-pass dynamic-programming labeling. An independent GRU classifier that never participates in the labeling loop reproduces the same trend, while label entropy and class coverage remain stable, indicating that the gain transfers across architectures and is not caused by label collapse. We further show that learnability is controlled by both iteration and the model-feedback weight $\beta_{\mathrm{model}}$. Iterative gains diminish as successive label systems converge, whereas stronger feedback increasingly widens the performance gap between the feedback Transformer and the independent GRU. Increased learnability is accompanied by declining segment-level price-feature separation after an initial improvement. Finally, a non-anticipative event study provides partial external validation: refinement strengthens a conditional BEAR$\rightarrow$BULL reversal signal on the three A-share datasets, while the corresponding effect has the opposite sign on NASDAQ100. These results position DDSL as a structured framework for constructing market-state labels whose learnability can be explicitly controlled and evaluated.

## Muon Attains $\\mathcal{O}(\\varepsilon^{-3})$ Iteration Complexity under Shuffling

DevFeed: [Muon Attains $\\mathcal{O}(\\varepsilon^{-3})$ Iteration Complexity under Shuffling](<https://devfeed.tech/articles/muon-attains-mathcal-o-varepsilon-3-iteration-complexity-under-shuffling-135867.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18124>)

Author: Kun Huang, Shi Pu, Karl Henrik Johansson

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>), [LLM Techniques](<https://devfeed.tech/topics/llm-techniques.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [accelerate](<https://devfeed.tech/tags/accelerate.md>), [beta](<https://devfeed.tech/tags/beta.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [momentum](<https://devfeed.tech/tags/momentum.md>), [muon](<https://devfeed.tech/tags/muon.md>), [practical](<https://devfeed.tech/tags/practical.md>), [sampling](<https://devfeed.tech/tags/sampling.md>)

### AI overview

For smooth nonconvex finite-sum problems, Muon with its momentum buffer orthogonalized by the polar map achieves O(ε⁻³) iterations to find an ε-stationary point under any sequence of shuffling permutations, including random reshuffling, shuffle once, and incremental gradient. This matches SGD's dependence on ε under shuffling and improves on Muon's O(ε⁻⁴) bound with sampling with replacement. The guarantee requires a problem-dependent β that approaches one as the number of components grows. The abstract also gives smooth convex examples where any fixed β fails to ensure stationarity for sufficiently many components, regardless of permutation or small stepsizes. Its suggested tuning response to stalled loss is to increase β while reducing the stepsize accordingly.

### Source excerpt

arXiv:2611.18124v1 Announce Type: cross Abstract: Muon is a stochastic first-order optimizer for matrix-valued parameters. It maintains an exponential moving average of stochastic gradients in a momentum buffer with coefficient $\beta$, and orthogonalizes the buffer to obtain the update direction. Muon has been reported to accelerate and stabilize the training of large language models. In practice, it is often used with shuffling (sampling without replacement), where each epoch visits the components of a finite-sum objective in a permuted order. However, its iteration complexity in this setting remains open. We analyze Muon under shuffling, with the momentum buffer orthogonalized by the polar map. For smooth nonconvex finite-sum problems, we establish an $\mathcal{O}(\varepsilon^{-3})$ iteration complexity for finding an $\varepsilon$-stationary point. This guarantee holds for every sequence of permutations, covering random reshuffling, shuffle once, and the incremental gradient method. This complexity matches that of stochastic gradient descent under shuffling in its dependence on $\varepsilon$, and improves on Muon's $\mathcal{O}(\varepsilon^{-4})$ complexity under sampling with replacement. Our guarantee requires a problem-dependent $\beta$ that approaches one as the number of components grows. In contrast, no fixed $\beta$ guarantees convergence to stationarity for every number of components. We show this by constructing a family of smooth convex problems on which, for any fixed $\beta\in[0,1)$, Muon remains bounded away from stationarity once the number of components is sufficiently large. This failure occurs for every sequence of permutations and persists even with small stepsizes. These results suggest two practical tuning rules: if the training loss stops decreasing even after reducing the stepsize, increase $\beta$; when increasing $\beta$, reduce the stepsize accordingly.

## Allocating Recurrent Compute in Looped Language Models

DevFeed: [Allocating Recurrent Compute in Looped Language Models](<https://devfeed.tech/articles/allocating-recurrent-compute-in-looped-language-models-132822.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.18230>)

Author: Ruhai Lin, Yiyang Guo, Rui-Jie Zhu, Hao Ye, Jason K. Eshraghian

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [compute](<https://devfeed.tech/tags/compute.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [recurrent](<https://devfeed.tech/tags/recurrent.md>)

### AI overview

MixerLoop repeats each Gated DeltaNet mixer while applying its dense feed-forward network once, targeting recurrent computation at operations whose later applications add observable cross-position influence. The paper uses Iterative Transport Rank to describe cumulative influence and marginal ITR to measure nonredundant contributions; a finite context-off intervention tests later applications' effects at the final language-model readout. Against no recurrence and full-block recurrence under matched data, initialization, and architecture, MixerLoop surpasses FullLoop on aggregate CORE at 15M parameters. At 110M, it retains 41.5% of its CORE improvement while reducing recurrent-backbone projection FLOPs by 45.9%. These reported results suggest recurrent depth benefits can be retained without repeatedly executing the dense FFN.

### Source excerpt

arXiv:2608.18230v2 Announce Type: replace Abstract: Looped language models improve reasoning and knowledge manipulation by applying shared computation repeatedly. Existing systems usually repeat an entire layer stack, although a mixer and a dense feed-forward network (FFN) perform different operations and have different costs. We ask a narrower question: what should loop? We view recurrence as repeated composition of a state update and argue that an application is valuable when it exposes a new cross-position influence direction that remains observable at the task readout. Iterative Transport Rank (ITR) describes the cumulative influence trajectory; marginal ITR describes the nonredundant influence contributed by successive applications. This view motivates MixerLoop, which repeats each Gated DeltaNet mixer while applying its dense FFN once. We compare MixerLoop with no recurrence and full-block recurrence at 15M and 110M parameters under the same data, initialization, and architecture. A finite context-off intervention tests whether later mixer applications produce distinct, non-negligible, and beneficial changes at the final language-model readout. MixerLoop surpasses FullLoop on aggregate CORE at 15M and retains 41.5% of its CORE improvement at 110M while reducing recurrent-backbone projection FLOPs by 45.9%. These results show that the benefits of recurrent depth can be retained without repeatedly executing the dense FFN.

## Closing the Loop: Co-Evolving EM for Irregular Time Series Generation in Lifted Representations

DevFeed: [Closing the Loop: Co-Evolving EM for Irregular Time Series Generation in Lifted Representations](<https://devfeed.tech/articles/closing-the-loop-co-evolving-em-for-irregular-time-series-generation-in-lifted-representations-132900.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.14659>)

Author: Idan Arbiv, Gal Fadlon, Omri Azencot

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Time Series](<https://devfeed.tech/topics/time-series.md>), [Temporal data](<https://devfeed.tech/topics/temporal-data.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [2d](<https://devfeed.tech/tags/2d.md>), [approach](<https://devfeed.tech/tags/approach.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [context](<https://devfeed.tech/tags/context.md>), [correlation](<https://devfeed.tech/tags/correlation.md>), [corruption](<https://devfeed.tech/tags/corruption.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [data](<https://devfeed.tech/tags/data.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [diffusion](<https://devfeed.tech/tags/diffusion.md>), [em](<https://devfeed.tech/tags/em.md>), [error](<https://devfeed.tech/tags/error.md>), [feature](<https://devfeed.tech/tags/feature.md>), [framework](<https://devfeed.tech/tags/framework.md>), [generation](<https://devfeed.tech/tags/generation.md>), [irregular](<https://devfeed.tech/tags/irregular.md>), [series](<https://devfeed.tech/tags/series.md>), [time](<https://devfeed.tech/tags/time.md>), [time-series](<https://devfeed.tech/tags/time-series.md>)

### AI overview

For generating regular time series from irregular observations, the paper argues that one-shot imputation is limited because point estimates average over ambiguous gaps and stochastic imputations can become stale as the generator changes. It proposes co-evolving Monte Carlo EM: each E-step samples missing values from the current generator's posterior, and each M-step retrains the generator on those completions. For a diffusion prior in a lifted 2D representation conditioned on time-series observations, PSLR is designed to maintain operator-consistent conditioning, uncertainty, and manifold consistency. Across ten datasets and four corruption regimes, the authors report gains over the strongest baselines in discriminative, predictive, Context-FID, and feature-correlation metrics; ablations report a 73% reduction in average discriminative score versus single-step baselines. These are abstract-level claims; the supplied excerpt gives no experimental details.

### Source excerpt

arXiv:2611.14659v1 Announce Type: new Abstract: Regular time-series generation from irregular time series is typically reduced to one-shot imputation: complete each partial sequence once, freeze the completions, and train a generator on the resulting surrogate dataset. We show that this open-loop strategy is structurally flawed. Point imputers collapse ambiguous missing regions to conditional averages, while stochastic imputers become stale as the generator evolves; the binding constraint is therefore iteration, not imputer design. We introduce a co-evolving Monte Carlo EM framework that closes the imputer-generator loop. Each E-step samples missing values from the posterior of the current generator, and each M-step retrains the generator on these completions, preserving unconditional generator training. Since our diffusion prior operates in a lifted 2D representation while observations live in time-series space, we further introduce Posterior Sampling for Lifted Representations (PSLR), which enforces operator-consistent conditioning, uncertainty preservation, and manifold consistency during the E-step. Across ten datasets and four corruption regimes, our method achieves state-of-the-art performance, improving over the strongest baselines by 59% in discriminative score, 15% in predictive score, 73% in Context-FID, and 71% in feature-correlation error. Ablations show that our approach reduces average discriminative score by 73% over single-step baselines, closing most of the remaining gap to the clean-data oracle. Code is available at https://github.com/azencot-group/PSLR.

## Amortized Score-Hamiltonian Policy Iteration: A Grid-Free Scheme for Relaxed Stochastic Control Problems

DevFeed: [Amortized Score-Hamiltonian Policy Iteration: A Grid-Free Scheme for Relaxed Stochastic Control Problems](<https://devfeed.tech/articles/amortized-score-hamiltonian-policy-iteration-a-grid-free-scheme-for-relaxed-stochastic-control-problems-123217.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.04285>)

Author: Qi Feng, Gu Wang

Published: 2026-11-09T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [actor](<https://devfeed.tech/tags/actor.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dimensions](<https://devfeed.tech/tags/dimensions.md>), [entropy](<https://devfeed.tech/tags/entropy.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [general](<https://devfeed.tech/tags/general.md>), [gradient](<https://devfeed.tech/tags/gradient.md>), [hamiltonian](<https://devfeed.tech/tags/hamiltonian.md>), [hjb](<https://devfeed.tech/tags/hjb.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [information](<https://devfeed.tech/tags/information.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [learning](<https://devfeed.tech/tags/learning.md>), [linear](<https://devfeed.tech/tags/linear.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [models](<https://devfeed.tech/tags/models.md>), [policy](<https://devfeed.tech/tags/policy.md>), [score](<https://devfeed.tech/tags/score.md>), [transport](<https://devfeed.tech/tags/transport.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The paper presents an amortized, grid-free actor-critic method for entropy-regularized infinite-horizon stochastic control. It replaces separate Langevin dynamics for each state with a conditional sampler shared across states and approximates value dynamics with a parametric critic; both are fitted at sampled states. A score loss measures actor agreement with the critic, while a policy-evaluation residual measures critic agreement with the actor. Gradient and Hessian residuals, including a Feynman-Kac representation for the gradient equation, address errors the projected iteration may miss. The authors combine these errors in an HJB residual decomposition to bound policy suboptimality, subject to verification and logarithmic Sobolev assumptions. In linear-quadratic problems, both projections are exact and recover pointwise iteration; numerical experiments on general models demonstrate high-dimensional coupled actor-critic learning.

### Source excerpt

arXiv:2610.04285v2 Announce Type: replace-cross Abstract: We develop an amortized, grid-free implementation of continuous Langevin dynamics based policy-value iteration for entropy-regularized, infinite-horizon relaxed stochastic control problems. The improvement rate of the exact iteration is a discounted aggregate of relative Fisher information between the policy and the Gibbs law of its Hamiltonian. The associated score residual is the velocity with which the control's Langevin dynamics transport its law. We project this velocity onto a conditional sampler shared across states, instead of one Langevin dynamics per state, and the value dynamics onto a parametric critic, estimating both projections at sampled states to obtain coupled actor--critic flows. The score loss measures the actor's agreement with the current critic, while the policy-evaluation residual measures the critic's agreement with the actor. We also derive gradient and Hessian residuals, including a Feynman--Kac representation for the gradient equation, to control errors not detected by the projected value iteration. An exact decomposition of the HJB residual combines these errors into a policy-suboptimality bound under verification and logarithmic Sobolev assumptions. In the linear-quadratic class, both projections are exact and recover the pointwise iteration, and we provide numerical experiments on general models to demonstrate the coupled actor--critic learning in high-dimensions.

## Writing a DSL for high performance parallel programming in OxCaml

DevFeed: [Writing a DSL for high performance parallel programming in OxCaml](<https://devfeed.tech/articles/writing-a-dsl-for-high-performance-parallel-programming-in-oxcaml-132544.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/writing-a-dsl-for-high-performance-parallel-programming-in-oxcaml/>)

Author: Nicholas Yang

Published: 2026-11-06T00:00:00Z

Content type: article

Language: en

Sources: [Jane Street](<https://devfeed.tech/sources/jane-street.md>)

Topics: [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [GPU](<https://devfeed.tech/topics/gpu.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [avx2](<https://devfeed.tech/tags/avx2.md>), [avx512](<https://devfeed.tech/tags/avx512.md>), [backend](<https://devfeed.tech/tags/backend.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [c](<https://devfeed.tech/tags/c.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [intern](<https://devfeed.tech/tags/intern.md>), [internship](<https://devfeed.tech/tags/internship.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The OxCaml DSL lets developers describe the computation for one output index in an SPMD kernel; its compiler builds a graph and uses runtime metaprogramming to specialize and compile OxCaml code for the chosen metric and target architecture. Kernels write each output entry once, enabling parallel execution. The compiler distinguishes uniform and per-lane values, and offers `if_`, `if_var` and `select`; unlike `select`, which evaluates both branches, `if_var` can skip an untaken branch. An A-normal-form IR makes transformations such as hoisting loop-invariant loads and processing four elements per loop iteration easier to represent and optimize. The initial JIT was much faster than the interpreter, about as fast as or slightly slower than manual OxCaml, and significantly slower than C AVX2/AVX512. The IR backend initially performed about the same as that JIT. Preliminary vectorization and constant-hoisting work brought results on par with C AVX2; scheduling improvements were still in progress, and the excerpt reports no final results for them.

### Source excerpt

The following is part of a series of posts about 2026 summer intern projects--for more, see "What the interns have wrought, special jumbo 2026 edition"

## IJev: Order-Invariant Decisions via Iterated Cyclic Reordering

DevFeed: [IJev: Order-Invariant Decisions via Iterated Cyclic Reordering](<https://devfeed.tech/articles/ijev-order-invariant-decisions-via-iterated-cyclic-reordering-115119.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.01015>)

Author: Youzhi Zhang

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [choice](<https://devfeed.tech/tags/choice.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [decision-models](<https://devfeed.tech/tags/decision-models.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [invariant](<https://devfeed.tech/tags/invariant.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [options](<https://devfeed.tech/tags/options.md>), [order](<https://devfeed.tech/tags/order.md>)

### AI overview

IJev addresses order-sensitive choices by repeatedly reordering options using a cyclically averaged distribution corrected for label priors, then applying another cyclic average. Each iterate is exactly invariant to the input option order; if iteration does not converge, IJev averages distributions across rounds. Across five benchmarks and five models, it reports zero flip rate in every setting. Uniformly averaging 20 rounds substantially improves calibration over a single cyclic average while retaining comparable accuracy. A descriptive choice of iteration horizon and averaging rule achieves the best or tied-best accuracy in all 25 settings.

### Source excerpt

arXiv:2611.01015v1 Announce Type: new Abstract: System One decision models answer a choice question in one forward pass, but their answer depends on the order in which options are listed, and their probabilities carry a prior over answer labels. An invariant ordering operator is any fixed function that returns the same ordered option list for every input order of a fixed option set. Starting from any such order and averaging a listwise readout over its K cyclic shifts removes the input order, but the decision still depends on the chosen cyclic class: those $K$ shifts are only one of the (K-1)! classes, and different invariant operators can select different classes. We propose IJev, which repeatedly reorders the options by the cyclic-averaged, label-prior-corrected distribution and runs another cyclic average. Every iterate is exactly input-order-invariant. When the iteration does not converge, we average the round distributions rather than return the last round. On five benchmarks and five models, IJev has flip rate zero in every cell. The default uniform average over T=20 rounds substantially improves calibration over a single cyclic average, and its accuracy is comparable. A descriptive choice of horizon and averaging rule is best or tied-best for accuracy in all 25 settings.

## Unbiased Low-Rank Approximation for Repeated Matrix-Vector Multiplication: Stability and Optimal Sampling

DevFeed: [Unbiased Low-Rank Approximation for Repeated Matrix-Vector Multiplication: Stability and Optimal Sampling](<https://devfeed.tech/articles/unbiased-low-rank-approximation-for-repeated-matrix-vector-multiplication-stability-and-optimal-sampling-114448.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.00787>)

Author: Kang Liu

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [iteration](<https://devfeed.tech/topics/iteration.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [approximation](<https://devfeed.tech/tags/approximation.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-na](<https://devfeed.tech/tags/cs-na.md>), [math-na](<https://devfeed.tech/tags/math-na.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [math-ra](<https://devfeed.tech/tags/math-ra.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [rank](<https://devfeed.tech/tags/rank.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

Unbiased low-rank matrix samples can still make the expected squared norm of repeated iterates grow, even when the original iteration converges. Under a fixed rank bound and independent sampling at each step, the paper derives the minimum achievable asymptotic growth factor, identifies when the expected squared norm can converge to zero, and characterizes when a fixed distribution attains that optimum. It also constructs finite-support optimal distributions in every attainable case, yielding the minimum rank needed for stability and sampling designs optimal under the rank constraint.

### Source excerpt

arXiv:2611.00787v1 Announce Type: cross Abstract: Replacing the matrix in an iteration with random low-rank matrices can reduce the cost of matrix-vector multiplication. However, even if the sampled matrices equal the original matrix in expectation, the expected squared norm of the random iterates may grow while the original iteration converges. Under a fixed rank bound, we study how to choose the distribution of these random matrices to minimize this growth when sampling independently at each step. We derive an exact formula for the optimal asymptotic growth factor and use it to determine when the expected squared norm can converge to zero. We then characterize precisely when a fixed sampling distribution achieves this optimal factor and construct finite-support optimal distributions in every attainable case. These results determine the minimum rank required for stability and provide optimal sampling designs under the prescribed rank constraint.

## RecIS: Unifying Sparse and Dense Computation for Efficient Recommendation Training

DevFeed: [RecIS: Unifying Sparse and Dense Computation for Efficient Recommendation Training](<https://devfeed.tech/articles/recis-unifying-sparse-and-dense-computation-for-efficient-recommendation-training-111754.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.41457>)

Author: Hua Zong, Shuai Yang, Zhengxiong Zhou, Qingtao Zeng, Jiawei Liu, Hao Wan, Hongbin Zhou, Jiahao Wang, Hao Zhang, Bencheng Yan, Yuheng Huang, Huimin Yi, Jiamang Wang, Han Zhu, Jian Xu, Bo Zheng, Lin Qu

Published: 2026-11-02T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [GPU](<https://devfeed.tech/topics/gpu.md>), [sharding](<https://devfeed.tech/topics/sharding.md>), [synchronization](<https://devfeed.tech/topics/synchronization.md>), [Feature Engineering](<https://devfeed.tech/topics/feature-engineering.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [aggregation](<https://devfeed.tech/tags/aggregation.md>), [communication](<https://devfeed.tech/tags/communication.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dataflow](<https://devfeed.tech/tags/dataflow.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [embedding](<https://devfeed.tech/tags/embedding.md>), [fusion](<https://devfeed.tech/tags/fusion.md>), [latency](<https://devfeed.tech/tags/latency.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [recommendation](<https://devfeed.tech/tags/recommendation.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [training](<https://devfeed.tech/tags/training.md>)

### AI overview

RecIS targets end-to-end training throughput by coordinating sparse feature processing, GPU embedding operations, and dense computation. Its adaptive fusion combines fragmented feature transformations with vectorized memory access; its embedding engine uses hash-based sharding, hierarchical communication, and specialized aggregation for forward and backward index structures; and its multistage pipeline overlaps future-iteration input preparation with current dense computation. Across representative industrial models and distributed platforms, the abstract reports up to 2.62x PICASSO's throughput and 1.15x TorchRec's, with step latency reductions of up to 61.5% and 12.9%, respectively. These are reported maxima; the excerpt does not specify per-model results or evaluation conditions.

### Source excerpt

arXiv:2610.41457v1 Announce Type: new Abstract: Modern recommender models scale sparse representations and dense computation together. They process thousands of heterogeneous feature fields, long user-behavior sequences, and trillion-scale Embedding parameters, while their dense networks increasingly use large Transformer architectures. The resulting execution mismatch creates fine-grained operations within stages, load imbalance and synchronization delays across devices, and GPU resource bubbles between stages. As models grow, these costs become a primary limit to scalable recommender training. Although existing systems improve Embedding caching and data prefetching, these inefficiencies still coexist in the GPU-centric workloads we study and jointly limit end-to-end throughput. We present RecIS, a unified framework for GPU-centric recommender training. RecIS treats the complete path from input features to dense computation as one optimization target and coordinates three complementary mechanisms. First, adaptive fusion combines fragmented feature transformations with vectorized memory access. Second, a GPU Embedding engine uses hash-based sharding and hierarchical communication to balance request placement and eliminate redundant transfers; it also specializes aggregation for forward and backward index structures. Third, a multistage pipeline overlaps input preparation for future iterations with dense computation in the current iteration. Together, these mechanisms reorganize a fragmented sparse front end into a dataflow that continuously feeds dense computation. We evaluate RecIS on representative industrial recommender models across distributed training platforms. Compared with PICASSO and TorchRec, RecIS reaches up to $2.62\times$ and $1.15\times$ their throughput, respectively, while reducing step latency by up to 61.5\% and 12.9\%. RecIS provides an efficient and scalable training system for large recommender models.

## Using the Python zip() Function for Parallel Iteration

DevFeed: [Using the Python zip() Function for Parallel Iteration](<https://devfeed.tech/articles/using-the-python-zip-function-for-parallel-iteration-110733.md>)

Original publisher: [Read original article](<https://realpython.com/python-zip-function/>)

Author: Leodanis Pozo Ramos

Published: 2026-10-31T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [function](<https://devfeed.tech/topics/function.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>), [Parameter](<https://devfeed.tech/topics/parameter.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [dict](<https://devfeed.tech/tags/dict.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [python](<https://devfeed.tech/tags/python.md>), [zip](<https://devfeed.tech/tags/zip.md>)

### AI overview

Python's `zip()` returns a lazy iterator of tuples pairing items from multiple iterables in order, making it useful for parallel loops and calculations. By default, iteration stops at the shortest input, so unmatched items are ignored; `itertools.zip_longest()` instead continues to the longest input and fills gaps with a chosen value. Since Python 3.10, `zip(..., strict=True)` raises `ValueError` when lengths differ. The tutorial also shows how `zip(*pairs)` separates paired sequences and how `dict(zip(keys, values))` creates a dictionary. Ordered sequences and dictionaries preserve meaningful pairings, while sets do not guarantee order.

### Source excerpt

Learn how to use the Python zip() function to iterate over multiple iterables in parallel, unzip sequences, and build dictionaries with less code.

## Python range(): Represent Numerical Ranges

DevFeed: [Python range(): Represent Numerical Ranges](<https://devfeed.tech/articles/python-range-represent-numerical-ranges-109905.md>)

Original publisher: [Read original article](<https://realpython.com/python-range/>)

Author: Geir Arne Hjelle

Published: 2026-10-30T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>), [NumPy](<https://devfeed.tech/topics/numpy.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [arguments](<https://devfeed.tech/tags/arguments.md>), [built-in](<https://devfeed.tech/tags/built-in.md>), [class](<https://devfeed.tech/tags/class.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [enumerate](<https://devfeed.tech/tags/enumerate.md>), [function](<https://devfeed.tech/tags/function.md>), [loops](<https://devfeed.tech/tags/loops.md>), [python](<https://devfeed.tech/tags/python.md>), [range](<https://devfeed.tech/tags/range.md>), [zip](<https://devfeed.tech/tags/zip.md>)

### AI overview

Python's `range` creates a lazy, reusable sequence of integers from an inclusive start to an exclusive stop, with an optional nonzero step. It accepts one, two, or three integer-like arguments; a negative step counts downward, and `list()` can materialize the values. Use it for fixed-count repetition or when iterating over numerical values. For ordinary sequence loops, iterate over elements directly; use `enumerate()` when you need indices and elements, and `zip()` to traverse multiple iterables together. Ranges support indexing, slicing, membership checks, and `len()`. `reversed()` provides reverse iteration but returns an iterator without range indexing or length; a reversed slice such as `[::-1]` retains a range and supports varied step sizes. Floating-point ranges require another approach, such as a custom class or NumPy's `arange()`.

### Source excerpt

Master the Python range() function, see how it works under the hood, and learn when enumerate() or zip() beat ranges in your loops.

## Generalized Agent Iteration: One Formal Framework for Iterative Policy Improvement and Recursive Self-Improvement

DevFeed: [Generalized Agent Iteration: One Formal Framework for Iterative Policy Improvement and Recursive Self-Improvement](<https://devfeed.tech/articles/generalized-agent-iteration-one-formal-framework-for-iterative-policy-improvement-and-recursive-self-improvement-107909.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.13406>)

Author: Hongyao Tang, Yi Ma, Pengyi Li, Yifu Yuan

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-evaluation](<https://devfeed.tech/tags/agent-evaluation.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [boundary](<https://devfeed.tech/tags/boundary.md>), [characterization](<https://devfeed.tech/tags/characterization.md>), [components](<https://devfeed.tech/tags/components.md>), [condition](<https://devfeed.tech/tags/condition.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [defects](<https://devfeed.tech/tags/defects.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [formal](<https://devfeed.tech/tags/formal.md>), [framework](<https://devfeed.tech/tags/framework.md>), [improvement](<https://devfeed.tech/tags/improvement.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [learning](<https://devfeed.tech/tags/learning.md>), [policy](<https://devfeed.tech/tags/policy.md>), [recursive-self-improvement](<https://devfeed.tech/tags/recursive-self-improvement.md>), [rsi](<https://devfeed.tech/tags/rsi.md>), [standard](<https://devfeed.tech/tags/standard.md>), [system](<https://devfeed.tech/tags/system.md>)

### AI overview

Generalized Agent Iteration (GAI) frames iterative policy improvement and recursive self-improvement as cycles of agent evaluation and improvement. It treats an agent as a system configuration with modifiable components and distinguishes cases along two dimensions: whether the improvement mechanism belongs to the agent, and whether its evaluation standard is externally grounded. The first separates classical generalized policy iteration, where both principles lie outside the agent, from RSI; the second classifies systems as anchored, subject to goal drift, or fully self-referential. The authors use these axes to compare existing systems and state potential RSI defects condition by condition, presenting GAI as an initial framework for analyzing and designing such systems.

### Source excerpt

arXiv:2609.13406v2 Announce Type: replace Abstract: When we speak of recursive self-improvement (RSI), are we speaking of a phenomenon, a mechanism, or a prospect? Towards autonomous and evolving intelligence, RSI is being claimed at many scales, while no single framework that formally describes these emerging instances exists. Its counterpart in the classical realm, iterative policy improvement, is characterized by generalized policy iteration (GPI), a framework of broad applicability with well-understood theoretical properties, but only where the update principle and the evaluation base lie outside the agent. In this paper, we propose Generalized Agent Iteration (GAI), a formal framework that describes iterative policy improvement and RSI as two cases of a single learning paradigm. GAI defines the agent as a configuration of modifiable components within a system and models the learning process as a cycle of agent evaluation and agent improvement. Two pivotal dials then distinguish the instances, in particular the systems that self-identify as RSI in recent work: whether the improving mechanism is part of the agent and whether the standard it is measured against is grounded outside it. The former dial delineates the boundary between GPI and RSI, and the latter determines a system's polarity as anchored, goal drift, or fully self-referential. Moreover, we use these coordinates to place existing systems on the same two axes and make the defects of recursive self-improvement statable one condition at a time. We see this paper as a first step toward exploring a formal characterization of RSI that rests on the classical account, makes existing systems comparable, and provides a principled basis for analyzing and designing new ones.

## An Exact Parallel Dense Gauss-Seidel Algorithm with Trade-Offs between Parallel Execution Time and Preprocessing Time

DevFeed: [An Exact Parallel Dense Gauss-Seidel Algorithm with Trade-Offs between Parallel Execution Time and Preprocessing Time](<https://devfeed.tech/articles/an-exact-parallel-dense-gauss-seidel-algorithm-with-trade-offs-between-parallel-execution-time-and-preprocessing-time-107590.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.39990>)

Author: Mugurel-Ionu\\c{t} Andreica, Pantelimon George Popescu, Eliana-Dina T\\^ir\\c{s}a

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [execution](<https://devfeed.tech/tags/execution.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The paper proposes an exact parallel Gauss-Seidel algorithm for dense linear systems that aims to improve on the stated O(n) best parallel execution time achievable without preprocessing, given enough processors. It trades additional preprocessing time for faster parallel runtimes, with a tunable balance between preprocessing cost and achievable runtime. The supplied text does not quantify the improvements or describe the algorithm's implementation.

### Source excerpt

arXiv:2610.39990v1 Announce Type: new Abstract: The Gauss-Seidel iterative method is commonly used for solving systems of linear equations because of its good convergence properties. However, the Gauss-Seidel algorithm cannot be easily parallelized because of the data dependencies existing at each iteration. The best parallel execution time for dense systems of equations is $O(n)$ given that enough processors are available and no preprocessing is performed. In this paper we propose a new parallel Gauss-Seidel algorithm which is capable of achieving better parallel runtimes at the expense of more preprocessing time. The algorithm can be tuned in order to provide convenient trade-offs between the preprocessing time and the best parallel runtime achievable by the algorithm.

## Conservative Policy Iteration For Zero-Sum POSGs

DevFeed: [Conservative Policy Iteration For Zero-Sum POSGs](<https://devfeed.tech/articles/conservative-policy-iteration-for-zero-sum-posgs-103196.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.36847>)

Author: Erwan C. Escudie, Matthia Sabatelli, Jilles Steeve Dibangoye

Published: 2026-10-28T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [central](<https://devfeed.tech/tags/central.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-gt](<https://devfeed.tech/tags/cs-gt.md>), [dynamic-programming](<https://devfeed.tech/tags/dynamic-programming.md>), [exploitability](<https://devfeed.tech/tags/exploitability.md>), [exploration](<https://devfeed.tech/tags/exploration.md>), [function](<https://devfeed.tech/tags/function.md>), [games](<https://devfeed.tech/tags/games.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [hyperplane](<https://devfeed.tech/tags/hyperplane.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [local](<https://devfeed.tech/tags/local.md>), [observable](<https://devfeed.tech/tags/observable.md>), [one](<https://devfeed.tech/tags/one.md>), [point](<https://devfeed.tech/tags/point.md>), [policy](<https://devfeed.tech/tags/policy.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [reductions](<https://devfeed.tech/tags/reductions.md>), [zero](<https://devfeed.tech/tags/zero.md>)

### AI overview

The proposed approximate policy-iteration algorithm for finite-horizon zero-sum partially observable stochastic games maintains one policy per player and updates them jointly along occupancy trajectories. Each update uses a single supporting hyperplane from the current joint policy instead of approximating a full central value function; local improvements alternate with conservative updates and persistent exploration, focusing computation on occupancy regions where the policy is exploitable. On the reported benchmarks, it is competitive at small horizons and often improves the runtime-exploitability trade-off at larger horizons versus PBVI, HSVI, and CFR+.

### Source excerpt

arXiv:2610.36847v1 Announce Type: new Abstract: Occupancy-state reductions make dynamic programming possible for zero-sum partially observable stochastic games (zs-POSGs). Existing point-based solvers usually optimise a central value function. This restores Bellman recursion, but it requires point-based updates over high-dimensional occupancy spaces. We introduce an approximate policy-iteration algorithm for finite-horizon zs-POSGs. The method maintains one policy per player and updates both jointly along occupancy trajectories induced by conservative policy updates. Instead of approximating a full central value function, each update uses a single supporting hyperplane induced by the current joint policy. The algorithm alternates local policy improvements, conservative updates, and persistent exploration. Computation is therefore concentrated on occupancy regions where the current joint policy is exploitable. On finite-horizon zero-sum POSG benchmarks, the method is competitive at small horizons and often improves the runtime-exploitability trade-off at larger horizons compared with PBVI, HSVI, and CFR+.

## AHEAD: Adaptive Neural Acceleration for Large-Scale Linear Programming

DevFeed: [AHEAD: Adaptive Neural Acceleration for Large-Scale Linear Programming](<https://devfeed.tech/articles/ahead-adaptive-neural-acceleration-for-large-scale-linear-programming-103940.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.36321>)

Author: Sihao Liu, Zhichao Hou, Huayue Gu, Raiyan Rahman, Liang Wu, Ruozhou Yu, Xiaorui Liu

Published: 2026-10-28T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [acceleration](<https://devfeed.tech/tags/acceleration.md>), [adaptive](<https://devfeed.tech/tags/adaptive.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [large](<https://devfeed.tech/tags/large.md>), [linear-programming](<https://devfeed.tech/tags/linear-programming.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [neural](<https://devfeed.tech/tags/neural.md>), [variables](<https://devfeed.tech/tags/variables.md>)

### AI overview

AHEAD accelerates large-scale linear programming by predicting primal and dual step sizes for first-order solvers while retaining their update rules. A weight-shared predictor uses compact solver statistics, and a learned handoff policy chooses how many inexpensive warm-start iterations to run for each instance and target accuracy; the solver then completes under its own termination criterion. This design aims to balance inference cost against solver time. On packing linear programs with up to 10^7 variables, the abstract reports 6.5-11.6x end-to-end speedups over Gurobi's first-order solver from a cold start, including unseen sizes and distributions. It also reports gains on PageRank linear programs across difficulty levels and target accuracies.

### Source excerpt

arXiv:2610.36321v1 Announce Type: new Abstract: Large-scale linear programs with millions of variables and constraints strain time and memory budgets. First-order methods such as the primal-dual hybrid gradient scale to this regime because they avoid matrix factorizations, but they require many iterations. Learned accelerators can reduce these iterations, yet fewer iterations do not guarantee a shorter solve. Learning inference also takes time, and running the accelerator longer trades solver time for inference time. Existing unrolled accelerators handle this trade-off poorly: each layer processes every variable and constraint, the predicted iterates still need solver refinement, and every instance runs the same layers. We therefore ask: What neural accelerator design achieves end-to-end speedups on large-scale linear programs across sizes and target accuracies? We introduce AHEAD, an accelerator that predicts step sizes for first-order linear programming solvers while keeping their update rules. Its weight-shared predictor reads compact solver statistics and rescales the primal and dual step sizes, so each warm-start iteration stays inexpensive and a short warm-start phase hands the solver a warm start. A learned handoff policy sets the number of warm-start iterations for each instance and target accuracy, after which the solver finishes under its own termination criterion. On packing linear programs with up to $10^7$ variables, AHEAD achieves $6.5$--$11.6\times$ end-to-end speedups over Gurobi's first-order solver from a cold start, including on instances of unseen sizes and distributions. The gains extend to PageRank linear programs and hold across difficulty levels and target accuracies.

## Python jettisons the native JIT, at least for now

DevFeed: [Python jettisons the native JIT, at least for now](<https://devfeed.tech/articles/python-jettisons-the-native-jit-at-least-for-now-102397.md>)

Original publisher: [Read original article](<https://www.infoworld.com/article/4241003/python-jettisons-the-native-jit-at-least-for-now.html>)

Author: Serdar Yegulalp

Published: 2026-10-27T15:47:05Z

Content type: news

Language: en

Sources: [InfoWorld](<https://devfeed.tech/sources/infoworld.md>)

Topics: [JIT](<https://devfeed.tech/topics/jit.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [deprecated](<https://devfeed.tech/topics/deprecated.md>), [Numba](<https://devfeed.tech/topics/numba.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cpython](<https://devfeed.tech/tags/cpython.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [developers](<https://devfeed.tech/tags/developers.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [jit](<https://devfeed.tech/tags/jit.md>), [language-en](<https://devfeed.tech/tags/language-en.md>), [long-running](<https://devfeed.tech/tags/long-running.md>), [mainline](<https://devfeed.tech/tags/mainline.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [native](<https://devfeed.tech/tags/native.md>), [october](<https://devfeed.tech/tags/october.md>), [performance](<https://devfeed.tech/tags/performance.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [programming-languages-python-software-development](<https://devfeed.tech/tags/programming-languages-python-software-development.md>), [python](<https://devfeed.tech/tags/python.md>), [reporting](<https://devfeed.tech/tags/reporting.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [speed](<https://devfeed.tech/tags/speed.md>), [steering](<https://devfeed.tech/tags/steering.md>), [storytype-news](<https://devfeed.tech/tags/storytype-news.md>), [support](<https://devfeed.tech/tags/support.md>), [technical](<https://devfeed.tech/tags/technical.md>)

### AI overview

CPython's experimental native JIT is being removed from the mainline after its proponents withdrew PEP 836, which the Steering Council said lacked detail on ongoing support, performance evaluation, and integration with debugging and profiling tools. The council also considered its projected speed gains too optimistic: measured improvements were small and limited to some workloads, including long-running tight loops. The maintainers cited limited capacity to carry the proposal forward while affirming their technical direction. Other developers may continue the work independently, but contributing it to CPython would face the same high bar. The article distinguishes this effort from PyPy's highly optimized JIT, which can offer much larger speedups but lags CPython and has compatibility and performance issues with external C modules, and from experimental add-ons such as CinderX. CPython's adaptive interpreter, introduced in Python 3.11, remains a broader performance initiative that improves programs without requiring rewrites.

### Source excerpt

The experimental just-in-time compiler, or JIT, for CPython will be removed after its maintainers missed deadlines for its formalization set by the Python Steering Council. According to reporting at LWN.net, the move comes after the council formally paused work on the JIT in June 2026 until it approved a Python Enhancement Proposal, or PEP, that described how the JIT could become a properly supported part of CPython. The JIT's proponents, Brandt Bucher and Savannah Ostrowski, originally drafted PEP 744 to explain the JIT's functionality, but this document did not explain how the JIT would be maintained and integrated in CPython. To answer that, they offered PEP 836, but still ran into pushback from the council, which found that PEP 836 lacked sufficient details about how the JIT would be supported, its performance would be evaluated, and how it would be integrated with debugging and profiling tools. The council also criticized the PEP for being overly optimistic about the performance gains to expect. Speed improvements for the CPython JIT were measurable, but small, and only improved performance for some classes of programs, such as those with long-running tight loops. On October 19, PEP 836 was withdrawn. "The Steering Council rightly sets a high bar for a proposal of this scope, and we don't feel we have the personal bandwidth to carry the current version forward," Ostrowski said. "We continue to believe in the technical direction outlined in the PEP, including free-threaded support and a method-based front end, and remain optimistic about the JIT's potential in CPython." Nothing forbids other developers from continuing where the JIT project left off. Withdrawing PEP 836 simply means that work on the JIT in the mainline edition of CPython won't go forward. Other developers are free to continue the work in their own way, perhaps in an alternative build of CPython, although they will face the same high bar if they want to contribute that work back to CPython. JIT pr

## Python while Loops: Repeating Tasks Conditionally

DevFeed: [Python while Loops: Repeating Tasks Conditionally](<https://devfeed.tech/articles/python-while-loops-repeating-tasks-conditionally-99122.md>)

Original publisher: [Read original article](<https://realpython.com/python-while-loop/>)

Author: Leodanis Pozo Ramos

Published: 2026-10-24T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [iteration](<https://devfeed.tech/topics/iteration.md>), [Python](<https://devfeed.tech/topics/python.md>), [if statement](<https://devfeed.tech/topics/if-statement.md>)

Tags: [infinite](<https://devfeed.tech/tags/infinite.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [loops](<https://devfeed.tech/tags/loops.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

Python's `while` loop repeats its indented body while its condition is true, making it useful when the number of iterations depends on a changing condition or is unknown. The tutorial shows how to update loop state, use `break` to exit and `continue` to skip the rest of one iteration, and use `else` for code that runs after natural termination without a break. Examples include waiting for a file, reading input until a sentinel value, processing items from a list, and retrying a connection. A `while True` loop can model continuous monitoring or a do-while pattern, but needs appropriate exit conditions; faulty conditions or state updates can cause unintended infinite loops. For iterating over a known collection, the text recommends `for` loops.

### Source excerpt

Master indefinite iteration with Python while loops: build simple and complex loops, use break and continue, and handle infinite loops.

## Sets in Python

DevFeed: [Sets in Python](<https://devfeed.tech/articles/sets-in-python-97826.md>)

Original publisher: [Read original article](<https://realpython.com/python-sets/>)

Author: Leodanis Pozo Ramos

Published: 2026-10-23T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [data type](<https://devfeed.tech/topics/data-type.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [actions](<https://devfeed.tech/tags/actions.md>), [added](<https://devfeed.tech/tags/added.md>), [addition](<https://devfeed.tech/tags/addition.md>), [alcohol](<https://devfeed.tech/tags/alcohol.md>), [all](<https://devfeed.tech/tags/all.md>), [code](<https://devfeed.tech/tags/code.md>), [define](<https://devfeed.tech/tags/define.md>), [effectively](<https://devfeed.tech/tags/effectively.md>), [explore](<https://devfeed.tech/tags/explore.md>), [know](<https://devfeed.tech/tags/know.md>), [learn](<https://devfeed.tech/tags/learn.md>), [operations](<https://devfeed.tech/tags/operations.md>), [python](<https://devfeed.tech/tags/python.md>), [set](<https://devfeed.tech/tags/set.md>), [with](<https://devfeed.tech/tags/with.md>), [work](<https://devfeed.tech/tags/work.md>)

### AI overview

Python sets are mutable, unordered collections of unique hashable elements, useful for removing duplicates, fast membership checks, and mathematical set operations. Create them with literals, `set()` (required for an empty set), or comprehensions; `set(iterable)` adds the iterable's items individually, while a literal keeps an iterable such as a tuple as one element. Elements must be hashable, so lists and dictionaries cannot be members. The tutorial covers union, intersection, difference, and symmetric difference, including a practical API distinction: operators require set operands, while most corresponding methods accept other iterables; `.symmetric_difference()` takes one argument. It also explains in-place updates, subset and disjoint checks, mutation and traversal methods, and sorting iteration with `sorted()` when order is needed. The performance discussion describes hash-based membership as efficient relative to lists and provides a benchmark script, but reports no measured results.

### Source excerpt

Learn to work effectively with Python sets: define set objects, explore the supported operations, and know when sets fit your code.

## An Explicit Feedback Contract for Iterative ML-Agent Harnesses

DevFeed: [An Explicit Feedback Contract for Iterative ML-Agent Harnesses](<https://devfeed.tech/articles/an-explicit-feedback-contract-for-iterative-ml-agent-harnesses-94813.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.28798>)

Author: Kehui Yao, Chuanbo Hu, Jiao Chen, Ramin Giahi, Reza Yousefi Maragheh, Lalitesh Morishetti, Ziwei Hong, Yiyun Su, Jianpeng Xu, Evren Korpeoglu, Kannan Achan

Published: 2026-10-22T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-harnesses](<https://devfeed.tech/tags/agent-harnesses.md>), [budget](<https://devfeed.tech/tags/budget.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [error](<https://devfeed.tech/tags/error.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [gap](<https://devfeed.tech/tags/gap.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [learning](<https://devfeed.tech/tags/learning.md>), [ml](<https://devfeed.tech/tags/ml.md>), [noise](<https://devfeed.tech/tags/noise.md>), [performance](<https://devfeed.tech/tags/performance.md>), [rank](<https://devfeed.tech/tags/rank.md>), [score](<https://devfeed.tech/tags/score.md>), [selection](<https://devfeed.tech/tags/selection.md>), [signal](<https://devfeed.tech/tags/signal.md>), [split](<https://devfeed.tech/tags/split.md>)

### AI overview

The proposed feedback contract limits adaptive selection by releasing a validation score only when a submission clears a noise threshold based on paired standard error; it also specifies when iteration stops and when the test split may be used. In experiments on click-through-rate prediction, learning to rank, and a no-signal control, exact-score feedback produced a reported gain of 0.0157 on the control, where the true gain was zero, compared with 0.0033 under the contract. The contract narrowed the validation-test gap on both real tasks, with slightly higher test performance, and stopped after four to twelve submissions. Exact feedback used all thirty submissions on two tasks, including the control.

### Source excerpt

arXiv:2610.28798v1 Announce Type: new Abstract: Iterative ML agents develop models by editing code, running experiments, reading a validation score, and choosing what to try next. In current harnesses this loop is served by an exact validation score returned after every attempt, which leaves the validation split open to adaptive selection. In this work, we introduce an explicit feedback contract for ML-agent harnesses, which specifies what an agent may observe, when iteration should stop, and when the test split may be touched. The contract releases a validation score only when a submission clears a noise threshold computed from the paired standard error, so no margin has to be tuned. We ran experiments on click-through-rate prediction, learning to rank, and a control task with no signal to find. The control is the sharpest case, because the true gain there is zero by construction: an agent reading exact scores ended by reporting a gain of 0.0157, while under the contract it reported 0.0033. On both real tasks the contract narrows the validation-test gap, and test performance is slightly higher rather than lower. The largest difference is in when the agents stop. Exact feedback used its entire budget of thirty submissions on two of the three tasks, including the one where nothing can be learned, while the contract halted after four to twelve. A run that exhausts its budget is usually read as diligence. It is better read as a symptom: when the feedback channel is unbounded, noise keeps supplying improvements to chase.

## Skipping domain reload: faster iteration using the MethodReload feature

DevFeed: [Skipping domain reload: faster iteration using the MethodReload feature](<https://devfeed.tech/articles/skipping-domain-reload-faster-iteration-using-the-methodreload-feature-96246.md>)

Original publisher: [Read original article](<https://unity.com/blog/skipping-domain-reload-faster-iteration-using-the-methodreload-feature>)

Author: Théo Richart; Mike Geig

Published: 2026-10-22T00:00:00Z

Content type: article

Language: en

Sources: [Unity](<https://devfeed.tech/sources/unity.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [Framework](<https://devfeed.tech/topics/framework.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [applications](<https://devfeed.tech/tags/applications.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [asset](<https://devfeed.tech/tags/asset.md>), [assets](<https://devfeed.tech/tags/assets.md>), [await](<https://devfeed.tech/tags/await.md>), [backend](<https://devfeed.tech/tags/backend.md>), [build](<https://devfeed.tech/tags/build.md>), [builds](<https://devfeed.tech/tags/builds.md>), [bytecode](<https://devfeed.tech/tags/bytecode.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [domain](<https://devfeed.tech/tags/domain.md>), [faster](<https://devfeed.tech/tags/faster.md>), [feature](<https://devfeed.tech/tags/feature.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [net](<https://devfeed.tech/tags/net.md>), [reload](<https://devfeed.tech/tags/reload.md>), [unity](<https://devfeed.tech/tags/unity.md>)

### AI overview

MethodReload speeds iteration by interpreting updated bodies of tagged methods in a running Unity Editor or development player, including IL2CPP builds, avoiding a full domain reload for those edits. The experimental package requires Unity 6.0+; tagged public methods must return void or IEnumerator, with tags present before Play Mode or player build. Its interpreter supports a C# subset, cannot alter fields, call sites, or type layout, and runs slower than compiled code during development. On devices, reloaded code can call only APIs retained in the build. Existing Asset Store hot reload tools offer full C# and a mature Mono Editor workflow, but cannot patch IL2CPP; .NET Hot Reload targets CoreCLR, not Unity Mono or IL2CPP. Larger changes still require normal compilation and reload.

### Source excerpt

Stop waiting on domain reloads! Learn how MethodReload speeds up Unity iteration time, explore its limitations, and compare it to existing hot reload tools.

## HarnessPro: Recursive Harness Self-Improvement with Pareto Optimization for Performance-Cost Trade-offs

DevFeed: [HarnessPro: Recursive Harness Self-Improvement with Pareto Optimization for Performance-Cost Trade-offs](<https://devfeed.tech/articles/harnesspro-recursive-harness-self-improvement-with-pareto-optimization-for-performance-cost-trade-offs-93670.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.26770>)

Author: Zhuoshi Pan, ZhiYuan Feng, Yukuo Cen, Honglin Lin, Junru Lu, Zhongxia Chen, Shuo Yang, H. Vicky Zhao, Jie Tang

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>), [LLM observability](<https://devfeed.tech/topics/llm-observability.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [execution](<https://devfeed.tech/tags/execution.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [glm](<https://devfeed.tech/tags/glm.md>), [glm-5-2](<https://devfeed.tech/tags/glm-5-2.md>), [harness](<https://devfeed.tech/tags/harness.md>), [improvement](<https://devfeed.tech/tags/improvement.md>), [llm](<https://devfeed.tech/tags/llm.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [pass](<https://devfeed.tech/tags/pass.md>), [performance](<https://devfeed.tech/tags/performance.md>), [self-improvement](<https://devfeed.tech/tags/self-improvement.md>), [trade](<https://devfeed.tech/tags/trade.md>)

### AI overview

HarnessPro evolves AI-agent harnesses using LLM-generated tests, without ground-truth solutions or official tests. Specialized agents analyze execution trajectories, plan updates with different performance-cost priorities, and implement candidate harnesses; execution feedback guides later iterations. A normalized weighted squared-distance selection offers lite, medium, and heavy variants for different deployment budgets. On Terminal-Bench 2, SWE-Bench Pro, and ProgramBench with GPT-5.5 and Codex, heavy mode averaged a 2.0 percentage-point pass-rate gain and 26.1% lower per-task cost than RHO; the abstract says this advantage also holds with GLM-5.2 and Claude Code.

### Source excerpt

arXiv:2610.26770v2 Announce Type: new Abstract: Harness development plays a crucial role in building capable AI agents. Recent approaches improve harnesses through recursive self-improvement (RSI), but their performance gains often come with higher execution costs. We introduce HarnessPro, a label-free method for evolving harnesses to improve task performance while reducing execution cost. In this setting, candidate harnesses are evaluated using LLM-generated tests without access to ground-truth solutions or official tests. Specialized agents diagnose execution trajectories, plan updates with different performance-cost priorities, and implement them as candidate harnesses. Rather than returning a single harness, HarnessPro uses normalized weighted squared-distance selection to provide cost-focused (lite), balanced (medium), and performance-focused (heavy) harnesses for different deployment budgets. Selected harnesses enter the next iteration, where execution feedback guides further updates. Our experiments cover Terminal-Bench 2, SWE-Bench Pro, and ProgramBench, using GPT-5.5 with Codex and GLM-5.2 with Claude Code. Across these benchmarks using GPT-5.5 with Codex, the heavy mode of HarnessPro achieves an average pass-rate gain of 2.0 percentage points and an average per-task cost reduction of 26.1% relative to RHO. This advantage also holds when using GLM-5.2 with Claude Code. Code is available at https://github.com/pzs19/HarnessPro

## Federated Community Detection in Bipartite Networks

DevFeed: [Federated Community Detection in Bipartite Networks](<https://devfeed.tech/articles/federated-community-detection-in-bipartite-networks-93582.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.25997>)

Author: Wanjie Wang

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [clustering](<https://devfeed.tech/topics/clustering.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [clustering](<https://devfeed.tech/tags/clustering.md>), [communities](<https://devfeed.tech/tags/communities.md>), [community-detection](<https://devfeed.tech/tags/community-detection.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [federated](<https://devfeed.tech/tags/federated.md>), [networks](<https://devfeed.tech/tags/networks.md>), [stat-co](<https://devfeed.tech/tags/stat-co.md>), [stat-me](<https://devfeed.tech/tags/stat-me.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>)

### AI overview

FLICKER estimates a specified singular direction in horizontally partitioned data using local matrix-vector products, so servers need not share raw data; target directions can be computed in parallel. Its extension, BiFLICKER, supports community detection in bipartite networks, while Sequential BiFLICKER handles nearby or repeated singular directions. The abstract reports non-asymptotic convergence guarantees and, under a sparse bipartite stochastic block model, vanishing misclustering and exact recovery under stronger sparsity conditions. Simulations find BiFLICKER close to centralized spectral clustering and more robust than federated baselines when local samples are small. On a country-partitioned LastFM user-artist network, Sequential BiFLICKER achieves ARI 0.94 against centralized clustering. These results are reported in the abstract; it does not provide implementation details.

### Source excerpt

arXiv:2610.25997v1 Announce Type: cross Abstract: We study federated spectral estimation when a large matrix is horizontally partitioned across servers that cannot share raw data. We propose FLICKER, a target-specific gradient-based power iteration that recovers a singular direction associated with a prescribed spectral target using only matrix-vector products on local blocks. Different target directions can be recovered independently and in parallel. We establish non-asymptotic convergence guarantees and provide a recursive grid-search procedure for spectral target selection. Building on FLICKER, we develop BiFLICKER for federated community detection in bipartite networks, together with a sequential projected variant for nearby or repeated singular directions. Under a sparse bipartite stochastic block model, we show that properly rescaled leading singular values from a reference server provide valid global targets, and that Sequential BiFLICKER achieves a vanishing misclustering rate and exact recovery under stronger sparsity conditions. Simulations show that BiFLICKER remains close to centralized spectral clustering and is more robust than existing federated spectral baselines when local sample sizes are small. On a LastFM user-artist network naturally partitioned by country, Sequential BiFLICKER attains an overall ARI of 0.94 against centralized clustering while revealing cross-country communities with distinct listening profiles.

## Compose the Horizon: Parameter-Shared Blockwise Forecasting under a Sequential-Compute Trade-off

DevFeed: [Compose the Horizon: Parameter-Shared Blockwise Forecasting under a Sequential-Compute Trade-off](<https://devfeed.tech/articles/compose-the-horizon-parameter-shared-blockwise-forecasting-under-a-sequential-compute-trade-off-93365.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.24826>)

Author: Zeyan Li, Weiheng Li, Shengda Zhuo, Libing Chen, Min Chen, Yin Tang

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [model architecture](<https://devfeed.tech/topics/model-architecture.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [blocks](<https://devfeed.tech/tags/blocks.md>), [compute](<https://devfeed.tech/tags/compute.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [error](<https://devfeed.tech/tags/error.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [forecasting](<https://devfeed.tech/tags/forecasting.md>), [memory](<https://devfeed.tech/tags/memory.md>), [model](<https://devfeed.tech/tags/model.md>)

### AI overview

Recursive Functional Decomposition (RFD) reuses one compact operator to forecast three contiguous, non-overlapping future blocks: each block is concatenated to the rolling context for the next prediction, rather than combined as trend, seasonal, or residual components. In three-seed experiments, removing forward feedback worsened results across all four datasets, while stopping gradients through feedback changed little; reusing the operator helped, but less than widening it. RFD uses 0.08-0.46M parameters, but sequential channel-wise execution was slower and more memory-intensive than an iterative baseline at high channel counts. Against ten baseline families, it had lower test error in 23 of 24 cells in a frozen long-context evaluation, though the protocols differed: RFD used 512/720-step contexts and baselines used 96.

### Source excerpt

arXiv:2610.24826v1 Announce Type: new Abstract: Most long-horizon forecasters emit the complete future in one pass. We ask whether a compact operator can instead be reused to emit contiguous future blocks, trading stored parameters for sequential computation. Recursive Functional Decomposition (RFD) factorizes the horizon mapping into three parameter-shared block predictions. The blocks occupy disjoint future intervals and are concatenated, not added as trend, seasonal, or residual components, and each emitted block joins the rolling context that conditions the next application. In controlled three-seed experiments, removing forward feedback hurts all four evaluated datasets while stopping gradients through it changes little, so the useful signal is the evolving forecast state itself; reapplying the shared operator helps consistently, but by less than widening it. The model uses 0.08--0.46M parameters, yet its sequential channel-wise execution is slower and more memory-intensive than an iterative baseline at high channel count. In a frozen long-context evaluation against ten strong baseline families, RFD records lower test error in 23 of 24 cells; the comparison is cross-protocol, with RFD using 512/720-step context and the baselines using 96.

[Next page](<https://devfeed.tech/topics/iteration.md?cursor=WyIyMDI2LTEwLTIxVDA0OjAwOjAwKzAwOjAwIiwgIjE5ZDE1MDUzLThlMGItNDY2Mi04ZjU5LWJhZDU1Y2U4MTMxOSJd>)