🔥 LiveEdit: Towards Real-Time Diffusion-Based Streaming Video Editing

💡 The paper introduces a novel streaming video editing framework called LiveEdit that enables real-time editing of videos with stable backgrounds and non-edited regions over time. The main challenge in streaming video editing is maintaining stable backgrounds and non-edited regions while achieving low latency for real-time interactive scenarios. Existing streaming video generation methods are not suitable for editing due to the strict preservation requirement and region-specific control.

To address this issue, the authors propose a three-stage distillation pipeline that transfers editing capability from a powerful bidirectional foundation model to an efficient unidirectional streaming editor. This pipeline enables stable long-horizon edits without sacrificing visual fidelity. Additionally, the authors introduce an AR-oriented mask cache that reuses region-related computation across frames, reducing redundant processing and accelerating inference.

The results show that the proposed method achieves state-of-the-art visual quality among streaming baselines and drastically boosts inference speed to 12.66 frames per second. This makes it suitable for interactive and augmented reality applications. The authors also establish a dedicated benchmark for streaming video editing to evaluate their method. Overall, the paper presents a significant contribution to the field of streaming video editing by providing a real-time and stable editing framework.

📅 Published on Jun 25

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2606.26740
• PDF: https://arxiv.org/pdf/2606.26740
• Project Page: https://arxiv.org/abs/2606.26740

🚀 Spaces citing this paper:
• https://huggingface.co/spaces/multimodalart/LiveEdit

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#VideoEditingTechniques #RealTimeStreaming #DiffusionBasedEditing #StreamingVideoGeneration #LowLatencyEditing

🔥 Qwen-RobotManip Technical Report: Alignment Unlocks Scale for Robotic Manipulation Foundation Models

💡 The paper presents Qwen-RobotManip, a generalizable Vision-Language-Action foundation model for robotic manipulation that achieves strong generalization through unified alignment across representation, motion, and behavior dimensions. The problem addressed is that robotic manipulation data is heterogeneous, expensive to collect, and narrow in diversity, making it challenging to achieve alignment and scale in training. The authors propose a unified alignment framework that enables large-scale multi-source training, allowing the model to absorb manipulation data at a scale that prior training regimes could not sustain.

The method involves a human-to-robot synthesis pipeline that converts egocentric hand demonstrations into robot trajectories across 15 platforms, and a rigorous curation pipeline that harmonizes heterogeneous datasets. The model is trained on a large pretraining corpus of approximately 38,100 hours, constructed using only open-source datasets and human videos without proprietary data collection.

The results show that Qwen-RobotManip exhibits emergent generalization capabilities, including zero-shot instruction following, robustness to perturbations, reactive error recovery, and cross-embodiment transfer. The model substantially outperforms prior state-of-the-art models, including π0.5, across all out-of-distribution settings, and ranks 1st in RoboChallenge with a 20% relative improvement. The model is also validated on real-robot platforms, including AgileX ALOHA, Franka, UR, and ARX. The paper concludes that Qwen-RobotManip achieves genuine generalization in robotic manipulation, demonstrating the effectiveness of the unified alignment framework and large-scale training approach.

📅 Published on Jun 17

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2606.17846
• PDF: https://arxiv.org/pdf/2606.17846
• Project Page: https://qwen.ai/blog?id=qwen-robotmanip

📊 Datasets citing this paper:
• https://huggingface.co/datasets/cy0307/awesome-egocentric-atlas

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#RobotLearning #FoundationModels #RoboticManipulation #VisionLanguageAction #MultiSourceTraining

🔥 PhysisForcing: Physics Reinforced World Simulator for Robotic Manipulation

💡 The paper proposes PhysisForcing, a framework for enhancing the physical consistency of embodied video generation models for robotic manipulation. The problem with existing video generation models is that they can produce physically implausible manipulations, such as discontinuous motion trajectories and inconsistent robot-object interactions. This is mainly due to the deformation of moving objects and implausible spatio-temporal correlations among interacting entities, particularly during contact.

To address this issue, PhysisForcing uses a scalable training framework that focuses supervision on physics-informative regions through joint optimization of pixel-level and semantic-level features. The framework consists of two losses: a pixel-level trajectory alignment loss that supervises features using reference point trajectories, and a semantic-level relational alignment loss that aligns features with inter-region relations extracted from a frozen video understanding encoder.

The method is evaluated on several benchmarks, including R-Bench, PAI-Bench, and EZS-Bench, and the results show that PhysisForcing consistently improves embodied video generation over strong baselines. Specifically, it improves the Wan2.2-I2V-A14B and Cosmos3-Nano base models on R-Bench by 22.3% and 9.2%, respectively, with the Cosmos3-Nano variant attaining the best overall score.

Furthermore, the paper demonstrates that PhysisForcing can be used as a world model under the WorldArena action-planner protocol, which raises the closed-loop success rate from 16.0% to 24.0% and further improves downstream policy success. This indicates that physically aligned video models yield stronger representations for robotic manipulation. Overall, the paper contributes a novel framework for enhancing the physical consistency of embodied video generation models, which has the potential to improve the reliability and performance of robotic manipulation systems.

📅 Published on Jun 26

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2606.28128
• PDF: https://arxiv.org/pdf/2606.28128
• Project Page: https://dagroup-pku.github.io/PhysisForcing.github.io/

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#RoboticsAndComputerVision #PhysicsInformedMachineLearning #RoboticManipulation #EmbodiedAI #ComputerVisionForRobotics

🔥 GenericAgent: A Token-Efficient Self-Evolving LLM Agent via Contextual Information Density Maximization (V1.0)

💡 The paper introduces GenericAgent, a self-evolving large language model agent system designed to overcome the limitations of long-horizon interactions. The main problem addressed is that as interactions become longer, the accumulation of tool descriptions, memories, and environmental feedback pushes out the information needed for decision-making, leading to poor performance. The authors argue that the key to improving long-horizon performance is not the length of the context, but rather how much decision-relevant information is maintained within a finite context budget.

To address this problem, the GenericAgent system is built around the principle of context information density maximization. The system consists of four main components: a minimal atomic tool set, a hierarchical on-demand memory, a self-evolution mechanism, and a context truncation and compression layer. The minimal atomic tool set keeps the interface simple, while the hierarchical on-demand memory only shows a small high-level view by default. The self-evolution mechanism turns verified past trajectories into reusable standard operating procedures and executable code, allowing the agent to learn from its experiences. The context truncation and compression layer maintains information density during long executions by removing unnecessary information.

The results show that GenericAgent consistently outperforms leading agent systems in terms of task completion, tool use efficiency, memory effectiveness, self-evolution, and web browsing. Moreover, GenericAgent achieves these results while using significantly fewer tokens and interactions, demonstrating its efficiency. The system also continues to evolve over time, allowing it to adapt to new situations and improve its performance. Overall, the paper presents a novel approach to building self-evolving large language model agents that can effectively handle long-horizon interactions and maximize context information density.

📅 Published on Apr 18

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2604.17091
• PDF: https://arxiv.org/pdf/2604.17091

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#TokenEfficientLLMs #SelfEvolvingAgents #ContextualInformationDensity #LargeLanguageModelAgents #LongHorizonInteractions

🔥 An Efficient Heterogeneous Co-Design for Fine-Tuning on a Single GPU

💡 The paper addresses the challenge of fine-tuning large language models on single GPUs, which is limited by the models' memory-intensive nature. To overcome this, the authors propose SlideFormer, a system designed for single-GPU environments. The key innovations of SlideFormer include a lightweight asynchronous engine that overlaps GPU computation with CPU updates and multi-tier I/O, a heterogeneous memory management scheme that reduces peak memory usage, and optimized kernels that solve key bottlenecks and integrate advanced I/O.

The asynchronous engine treats the GPU as a sliding window, allowing for efficient processing. The heterogeneous memory management scheme significantly reduces memory usage, making it possible to fine-tune larger models. The optimized kernels improve performance by solving key bottlenecks and integrating advanced I/O.

The results show that SlideFormer achieves higher throughput and reduced memory usage compared to baselines. Specifically, it supports up to 8 times larger batch sizes and 6 times larger models, and achieves 1.40 to 6.27 times higher throughput while roughly halving CPU and GPU memory usage. The system sustains over 95 percent peak performance on both NVIDIA and AMD GPUs, demonstrating its effectiveness and efficiency. Overall, SlideFormer enables the fine-tuning of large language models on single GPUs, making it a significant contribution to the field of natural language processing.

📅 Published on Mar 17

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2603.16428
• PDF: https://arxiv.org/pdf/2603.16428

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#HeterogeneousCoDesign #GPUMemoryOptimization #LanguageModelFineTuning #SingleGPUComputing #AsynchronousProcessingTechniques

🔥 BlockPilot: Instance-Adaptive Policy Learning for Diffusion-based Speculative Decoding

💡 The paper introduces BlockPilot, a method for improving the efficiency of speculative decoding in natural language processing tasks. Speculative decoding is a technique that uses a lightweight model to generate candidate tokens in parallel, which are then verified by a target model. Existing methods use a fixed block size for decoding, which can be suboptimal as the optimal block size varies across different input samples. The authors show that the optimal block size is critical to speculative decoding performance and that it exhibits a local structure, meaning that it tends to concentrate around the training block size.

To address this issue, the authors propose a sample-adaptive policy that predicts the optimal block size from the prefilling representation. This is done by formulating block size selection as a lightweight policy learning problem, where the optimal block size is predicted based on the representation of the prefilling stage. The prediction is performed only once after prefilling, allowing for seamless integration with existing models.

The authors evaluate their method on several benchmarks and demonstrate that it is plug-and-play, introduces minimal overhead, and consistently improves efficiency. The results show that BlockPilot achieves an acceptance length of 5.92 and a 4.20 times speedup on a specific model, indicating that it can significantly accelerate inference while maintaining accuracy. Overall, the paper contributes to the development of more efficient and adaptive speculative decoding methods, which can be useful for a wide range of natural language processing applications.

📅 Published on Jun 30

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2606.31315
• PDF: https://arxiv.org/pdf/2606.31315

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#InstanceAdaptivePolicyLearning #DiffusionBasedSpeculativeDecoding #NaturalLanguageProcessing #SpeculativeDecodingTechniques #BlockPilotMethod

🔥 GEAR: Guided End-to-End AutoRegression for Image Synthesis

💡 The paper introduces GEAR, a method for training a vector-quantized tokenizer and an autoregressive generator jointly and end-to-end for image synthesis. Typically, these models are trained in two stages, where the tokenizer is first trained and then frozen, and then the generator is trained on its output. However, this approach has a limitation, as the tokenizer is not aware of what the generator finds easy to model.

GEAR overcomes this limitation by training the tokenizer and generator jointly, guided by representation alignment. The key challenge is that the output of the tokenizer is non-differentiable, making it difficult to train the tokenizer and generator jointly. To address this, GEAR uses a dual read-out approach, where the tokenizer output is used in two different ways. A hard, one-hot branch is used to train the autoregressive generator, while a differentiable soft branch is used to carry a representation-alignment loss that guides the tokenizer.

This approach allows the autoregressive generator to steer the tokenizer towards an index distribution that it can predict more easily. As a result, the tokenizer's features become less complex, while the autoregressive generator's features become more complex and semantic. The paper demonstrates that GEAR speeds up convergence by up to 10 times relative to a strong baseline, and learns better patch-level and spatially-coherent features. Additionally, GEAR generalizes across different quantizers and can be applied to text-to-image generation. Overall, GEAR provides a new approach for training visual generative models, and achieves state-of-the-art results in image synthesis.

📅 Published on Jun 30

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2606.32039
• PDF: https://arxiv.org/pdf/2606.32039
• Project Page: https://linb203.github.io/gear

🤖 Models citing this paper:
• https://huggingface.co/BinLin203/Warmup-LFQ
• https://huggingface.co/BinLin203/Warmup-IBQ
• https://huggingface.co/BinLin203/GEAR-VQ

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#ImageSynthesis #AutoRegression #VectorQuantization #EndToEndLearning #AutoregressiveGenerators

🔥 Fast and Faithful: Real-Time Verification for Long-Document Retrieval-Augmented Generation Systems

💡 The paper presents a real-time verification system for retrieval-augmented generation that can process long documents and balance latency constraints with comprehensive answer validation. The problem addressed is that verifying generated answers in retrieval-augmented generation systems is difficult due to the large size of the source materials and the need for interactive services to respond quickly. Large language models can check long contexts but are too slow and costly, while lightweight classifiers operate within strict context limits and frequently miss evidence outside truncated passages.

The method proposed is a real-time verification component integrated into a production retrieval-augmented generation pipeline that enables full-document grounding under latency constraints. The system can process documents up to 32K tokens and employs adaptive inference strategies to balance response time and verification coverage across workloads.

The results show that full-context verification substantially improves detection of unsupported responses compared with truncated validation. The evaluation methodology used to deploy the verifier highlights the importance of long-context verification, the limitations of chunk-based checking in real documents, and the impact of latency budgets on model design. The findings provide practical guidance for practitioners building reliable large-scale retrieval-augmented applications, demonstrating that the proposed system can effectively verify generated answers in real-time while maintaining comprehensive coverage of the source materials.

📅 Published on Mar 4

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2603.23508
• PDF: https://arxiv.org/pdf/2603.23508

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#RealTimeVerification #RetrievalAugmentedGeneration #LongDocumentProcessing #AnswerValidationSystems #LatencyConstrainedVerification

🔥 AReaL: A Large-Scale Asynchronous Reinforcement Learning System for Language Reasoning

💡 The paper presents AReaL, a large-scale asynchronous reinforcement learning system designed for training large language models on reasoning tasks. The problem with existing synchronous reinforcement learning systems is that they alternate between generation and training in a batch setting, which leads to severe system-level inefficiency and underutilization of GPUs. This is because generation must wait until the longest output in the batch is completed before the model can be updated.

To address this issue, AReaL decouples generation from training, allowing rollout workers to continuously generate new outputs without waiting, while training workers update the model whenever a batch of data is collected. This asynchronous approach leads to substantially higher GPU utilization. To stabilize reinforcement learning training, AReaL balances the workload of rollout and training workers to control data staleness and adopts a staleness-enhanced PPO variant to better handle outdated training samples.

The results show that AReaL achieves up to 2.57 times training speedup compared to the best synchronous systems with the same number of GPUs, while matching or even improving final performance. The system was tested on math and code reasoning benchmarks, demonstrating the effectiveness of the asynchronous approach. The code for AReaL is made available, allowing others to build upon and utilize the system. Overall, AReaL provides a more efficient and scalable solution for training large language models on reasoning tasks using reinforcement learning.

📅 Published on May 30, 2025

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2505.24298
• PDF: https://arxiv.org/pdf/2505.24298

🤖 Models citing this paper:
• https://huggingface.co/inclusionAI/AReaL-boba-2-8B
• https://huggingface.co/inclusionAI/AReaL-boba-2-14B
• https://huggingface.co/inclusionAI/AReaL-boba-2-8B-Open

📊 Datasets citing this paper:
• https://huggingface.co/datasets/inclusionAI/AReaL-tau2-data

🚀 Spaces citing this paper:
• https://huggingface.co/spaces/rzvn/Medieval-Village-AI

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#AsynchronousReinforcementLearning #LanguageReasoningTasks #LargeScaleLanguageModels #ReinforcementLearningSystems #DeepLearningForNaturalLanguageProcessing

🔥 Perceive-to-Reason: Decoupling Perception and Reasoning for Fine-Grained Visual Reasoning

💡 The paper introduces a unified framework called Perceive-to-Reason that improves fine-grained visual reasoning performance on high-resolution images. Fine-grained visual reasoning is a challenging task for vision-language models, especially when small but critical visual cues are buried in high-resolution images. Existing approaches typically do not explicitly distinguish between perception and reasoning, instead relying on repeated cropping or test-time visual search to introduce local evidence.

The Perceive-to-Reason framework addresses this limitation by formulating fine-grained visual reasoning as a two-stage process. In the first stage, the model localizes question-relevant evidence as a Perceiver, and in the second stage, it answers the question as a Reasoner based on the annotated image and cropped regions. To train the model, the authors introduce a role-aware reinforcement learning strategy called Perception-Reasoning Alternating GRPO, which alternates between perception-focused and reasoning-focused updates using only final-answer supervision.

The Perceive-to-Reason framework is built on top of existing vision-language models, and it consistently improves performance across model scales. The results show that the Perceive-to-Reason framework achieves state-of-the-art performance on several benchmarks, including V-Star, HR-Bench-4K, and HR-Bench-8K. Specifically, the P2R-4B model achieves 93.2 percent on V-Star, 81.9 percent on HR-Bench-4K, and 80.5 percent on HR-Bench-8K, substantially outperforming its corresponding backbone.

The benefits of the Perceive-to-Reason framework extend beyond high-resolution benchmarks to broader multimodal reasoning tasks. The results suggest that explicitly decoupling perception from reasoning provides an effective framework for fine-grained visual reasoning. Overall, the paper contributes a novel framework for fine-grained visual reasoning that improves performance on high-resolution images and has broader implications for multimodal reasoning tasks.

📅 Published on Jul 1

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2607.01191
• PDF: https://arxiv.org/pdf/2607.01191

🤖 Models citing this paper:
• https://huggingface.co/hongxingli/P2R-4B
• https://huggingface.co/hongxingli/P2R-2B
• https://huggingface.co/hongxingli/P2R-8B

📊 Datasets citing this paper:
• https://huggingface.co/datasets/hongxingli/P2R-10k

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#FineGrainedVisualReasoning #VisualReasoningModels #PerceptionAndReasoning #HighResolutionImageAnalysis #VisionLanguageModels

🔥 Free IT Cert Resources – Grab Them While They're Hot!

🌈SPOTO just dropped a bunch of 100% free study kits for 2026 – covering #Cisco, #AWS, #PMP, #AI, #Python, #Excel, and #Cybersecurity

💥No signup traps, no hidden fees – just click and download.

📘 FREE Cert E‑Book → https://bit.ly/4wkiLAT
🪜 Online FREE Course → https://bit.ly/4vHFJSz
☁️ FREE AI Materials → https://bit.ly/4wdu7X6
📊 Cloud Study Guide → https://bit.ly/4y0HyeW
🧠 Free Mock Exam → https://bit.ly/4ff8jos

Tag a friend who's also on this journey – Get certified together! 💪

🌐 Join the community: https://chat.whatsapp.com/FmbIbbqm2QhKglVpVTSH4d/
📲 Need personalized help? → https://wa.link/6k7042