标签：#AR

Introduction Pattern matching, a powerful feature in many programming languages, allows developers to deconstruct complex data structures with elegance and precision. However, when it comes to dictionaries , this elegance can mask a critical issue: non-strict shape matching . Unlike sequence patterns, which demand an exact match, dictionary pattern matching in certain languages silently ignores unspecified keys. This behavior, while seemingly flexible, can lead to unexpected bugs and security vulnerabilities if developers assume strict shape enforcement. To illustrate, consider a dictionary pattern match in a language like Python or Rust. If you write a pattern to match a dictionary with keys {'a', 'b'} , and the actual dictionary contains {'a', 'b', 'c'} , the match will succeed, and the key 'c' will be ignored. This might seem harmless, but it violates the developer’s expectation of a strict shape match, akin to what sequence patterns provide. The causal chain here is straightforward: impact (developer assumes strict matching) → internal process (language ignores unspecified keys) → observable effect (unexpected behavior or bugs). The root of this issue lies in the design choice of prioritizing flexibility over strictness. Languages often default to this behavior to accommodate varying data shapes, but this comes at the cost of clarity and predictability. Compounding the problem is the lack of clear documentation or understanding of this behavior, leading developers to make incorrect assumptions based on their experience with sequence patterns. For instance, in a system where data integrity is critical, such as financial transactions or security protocols, silently ignoring keys could lead to data corruption or unauthorized access . If a developer expects a dictionary to have exactly three keys but the pattern matches a dictionary with four, the extra key might contain malicious data or disrupt downstream logic. The mechanism of risk formation here is the mismatch

hello everyone. I'm training PPO variants on different multi-agent tasks from the VMAS library (Independent PPO / Graph PPO and such, see HetGPPO by Bettini et al.). I noticed that for every architecture/scenario couple, the optimal hyperparameters sometimes tend to vary (learning rate, entropy coefficient, KL coefficient, SGD batch size, etc). do I need - methodologically speaking - to unify the hyperparameters of all models in order to make a fair and correct comparison of architectures later on? note: sometimes unifying these HP leads to some non converging models. note 2 : my objective is to test these models' robustness under adversarial attack in test-time (frozen models). thank you in advance. submitted by /u/ham_bam0 [link] [留言]

With advice from infectious disease experts, I tested a low-effort way to pasteurize eggs at home.

Zooming in on your kid's performance in the school play is about to get a whole lot easier. It's going to look better, too.

Salmonella outbreaks are seemingly everywhere right now. A good temperature probe is the last and best line of defense.

Make the most of Disrupt's crowds of potential investors and partners by exhibiting your startup from October 13-15.

Anyone else actually dealt with this? Is it overblown, or am I missing something? submitted by /u/Positive-Ad3618 [link] [留言]

At TechCrunch Disrupt 2026, Replit CEO Amjad Masad will share his perspective on the future of programming and Replit's role in developing it.

Apply before September 4 to be a part of the TechCrunch Disrupt community by hosting your own Side Event.

The eBoost brake-by-wire system is responsible for at least 22 crashes now.

I'm one of the co-authors of this paper. It's a seminal work in exploring the properties of 3D generated by LLMs via spatial programming. I've set up visual demonstrations of such 3D objects at: https://nova3d.xyz/ Scroll down and notice how the various 3D objects are all composed of logical parts and enable natural movements out of the box. There's a github repo in there as well. Under the hood: We found that 3D that exists as software is much more useful than typical monolithic mesh blobs generated by traditional AI 3D generators. For instance they are animation-ready and programmable from inception. They can contain the logic - at birth - to appear differently in weak compute environments (e.g. mobiles) vs powerful environments (e.g. sophisticated game engines). They can be built with full hierarchical structure and hinge/socket articulation at authoring time. They lag behind traditional AI 3D generators in creating complex organic shapes. But it naturally feels like code will eventually eat all 3D, as LLMs are getting better and better at spatial coding. Industries most disrupted will be industrial design, game development, simulations and AR/VR/XR. submitted by /u/mhb_11 [link] [留言]

As the title says, we haven't seen any like ACL provided. Very salty about the decision, as AC recommended findings and the reviewers tanked our paper intentionally (we flagged them, and AC acknowledged that). Just want to see if the decision was made based on poor reviewer scores, as we don't know if we need to resubmit to an ARR cycle to cleanse or not. submitted by /u/Massive-Bobcat-5363 [link] [留言]

Hi! Not sure if this community is suitable for this, if not, please let me know and I will take it down. My parents love sharing online content with me, we love animals so a lot of that is cute animal stuff, and lately I've been getting a lot of AI cats. I gave them some hints so they spot the obvious ones but not all the time. We haven't yet had an election cycle with AI content being this common, and it scares me a bit. I appreciate your support! submitted by /u/hakansan [link] [留言]

We are pleased to announce the latest major version of the NgRx framework, featuring exciting new features, bug fixes, and other updates. Resource Extensions 🧩 Angular's resource and httpResource APIs cover a large part of async state management, but two very common requirements are not configurable at the resource level: Value on loading: when a resource reloads, value() resets to undefined until the new data arrives. Value on error: when a resource enters the error state, reading value() throws. The new @ngrx/signals/resource entry point addresses both cases with resource extensions : a set of utilities for customizing the behavior of a Resource in a composable, reusable way. They wrap an existing resource and patch only the parts of its behavior that should change, while fully preserving the original resource type. The extendResource function accepts the resource as the first argument, followed by the extensions to apply: import { Component } from ' @angular/core ' ; import { httpResource } from ' @angular/common/http ' ; import { extendResource , withPreviousValueOnLoading , withValueOnError , } from ' @ngrx/signals/resource ' ; @ Component ({ /* ... */ }) export class TodoList { // type: HttpResourceRef<Todo[] | undefined> readonly todosResource = extendResource ( httpResource < Todo [] > (() => ' /api/todos ' ), withPreviousValueOnLoading (), withValueOnError ( undefined ) ); } The returned resource is still the exact resource that was passed in, so no access is lost to the APIs of more specific resource types, such as WritableResource . Only value() behaves differently: it keeps the previously loaded todos while a reload is in flight, and returns undefined instead of throwing when the request fails. Built-in Extensions There are four built-in extensions: withPreviousValueOnLoading keeps the last resolved value while the resource is reloading, which is exactly what paginated and filtered lists need to avoid flickering. withValueOnLoading returns a specific fal

This is a Plain English Papers summary of a research paper called OpenART Red-Teams Stateful Agents Across 10,000 Evolving Environment Scenarios . If you like these kinds of analyses, you can find more AI and machine-learning research on AIModels.fyi or follow us on Twitter . OpenART turns persistent state into the red-team target OpenART evaluates agent safety across more than 10,000 validated stateful scenarios spanning 50 domains and requiring a median of 97 tool calls. Its central claim is that safety failures can emerge from trajectories in which workspace data, permissions, memory, and plans are repeatedly modified, rather than from isolated prompts alone. The arena keeps each benign task objective and hidden safety contract fixed while changing only the target-visible environment state. This design targets delayed failures that static benchmarks can miss: an early authorized mutation may influence later decisions, expose protected resources, or produce unsafe output many steps after the original change. OpenART extends the broader idea of agent safety evaluation by making persistent environment state the object that evolves during testing. OpenART reports a pooled strict Attack Success Rate of 85.0% across 75 agent-model configurations. Strict success requires both the deterministic evaluator and a GLM-5.2 judge to identify the attack condition, so disagreements count as failures rather than being treated as partial evidence.... Continue reading the full paper summary on AIModels.fyi →

This is a Plain English Papers summary of a research paper called RA-Bench Reveals Why Crisis-Video Deepfake Detectors Fail Across Generators and Social Media . If you like these kinds of analyses, you can find more AI and machine-learning research on AIModels.fyi or follow us on Twitter . The crisis detection problem we've been getting wrong Video synthesis has reached an inflection point. Recent generators can fabricate realistic depictions of wars, natural disasters, infrastructure failures, and public emergencies so convincingly that they fool both people and current detection systems. The threat isn't hypothetical anymore. A fabricated video of a nuclear plant explosion, a hospital collapse during an earthquake, or a terrorist attack could trigger panic, military response, or severe economic disruption within hours. Yet here's the troubling part: we don't actually know if our best detection tools can handle these high-stakes scenarios in the wild. Researchers have built impressive deepfake detectors, trained them on standard benchmarks, and measured their performance. But those benchmarks test detectors against generic synthetic videos, not against the specific threat that actually matters: AI-generated crisis footage designed to fool people about real things that happened. It's like training a border guard to spot counterfeit passports in a lab with perfect lighting and a magnifying glass, then sending them to a busy airport where they have to make decisions in three seconds. The guard's failure has nothing to do with their skill. The problem is that the testing environment was completely divorced from the real scenario.... Continue reading the full paper summary on AIModels.fyi →

This article is to update VMware appliance ovf properties through command line. Sometimes we cannot access VC and only can access VMs through ESX UI. Check over properties exists in VM login to VM as root and execute ovfenv command root@vcf91-installer [ ~ ]# ovfenv [vm.vmname]=VCF-SDDC-Manager-Appliance-9.1.0.0300.25536191 [ROOT_PASSWORD]= [LOCAL_USER_PASSWORD]= [vami.hostname]=vcf91-installer.mylab.com [guestinfo.ntp]=172.30.20.3 [vami.ip_address_version.SDDC-Manager]=IPv4 [vami.ip0.SDDC-Manager]=172.30.20.12 [vami.netmask0.SDDC-Manager]=255.255.255.0 [vami.gateway.SDDC-Manager]=172.30.20.1 [vami.ipv6.SDDC-Manager]=null [vami.ipv6_prefix.SDDC-Manager]=null [vami.ipv6_gateway.SDDC-Manager]=null [vami.domain.SDDC-Manager]=mylab.com [vami.searchpath.SDDC-Manager]=mylab.com [vami.DNS.SDDC-Manager]=172.30.20.2,172.30.20.3 Change the directory to the VM scripts folder where all the firstboot and subsequent boot scripts are stored. cd /opt/vmware/vcf/commonsvcs/scripts/ Example to change NTP server details cd /opt/vmware/vcf/commonsvcs/scripts/ntp/ root@vcf91-installer [ /opt/vmware/vcf/commonsvcs/scripts/ntp ]# ls -ltr total 12 -r-xr-x--- 1 root vcf 853 Jun 27 02:53 update-ntp_server.sh -r-xr-x--- 1 root vcf 231 Jun 27 02:53 setup-ntp.sh -r-xr-x--- 1 root vcf 45 Jun 27 02:53 refresh-ntp.sh ./update-ntp_server.sh 172.30.20.250 reboot the VM

submitted by /u/esporx [link] [留言]

This is a Plain English Papers summary of a research paper called Macaron-V1: Continual Learning with Self-Improvement and Mixture-of-LoRA Adapters . If you like these kinds of analyses, you can find more research on AIModels.fyi or follow us on Twitter . The problem with frozen models Most AI systems today follow a familiar pattern: train, evaluate, deploy, and then stop. The model is locked at that moment, treated as a finished product rather than a living system. But the real world immediately begins to diverge from training data. Users interact with the system in ways the training process never anticipated. New domains emerge. Preferences shift. The model that seemed smart on test day becomes gradually less relevant over time. This frozen-in-place approach isn't accidental. It reflects how machine learning has been practiced for decades. Retraining is expensive. Deploying new versions carries risk. The infrastructure to continuously improve systems in production barely exists. So instead, teams ship a model and move on, accepting that it will decay slowly but inevitably. Macaron-V1 asks a different question: what if AI systems could continuously improve themselves through real-world experience, learning from the billions of interactions that happen after deployment? Not in theory, but actually, in production, with users. The answer isn't magic. It requires two architectural shifts. First, treat deployment as the beginning of a learning process, not the end of one. Build versioning, evaluation contracts, and feedback loops directly into the system. Second, stop assuming you need to retrain your entire model. Instead, freeze a stable base and compose lightweight specialist adapters around it, allowing the system to grow in capability without losing its foundation. Rethinking deployment as a continuous learning opportunity The insight here is architectural. Instead of viewing the deployed model as the final form, Macaron-V1 treats it as the first link in an infinit

This is a Plain English Papers summary of a research paper called BDH-CQ Uses Recurrent Latent Reasoning to Cut ARC-AGI Inference Costs . If you like these kinds of analyses, you can find more research on AIModels.fyi or follow us on Twitter . The cost-accuracy trap in visual reasoning Large language models are fundamentally mismatched for visual reasoning tasks. They're forced to describe every thought out loud, generating token after token to explain their logic. This verbosity taxes compute budgets, yet paradoxically doesn't improve performance. Ask a language model to solve an ARC-AGI puzzle (a visual reasoning benchmark designed to test abstract thinking), and it either struggles despite the verbosity or succeeds expensively. The root problem runs deeper than just inference cost: the model learns from demonstrations by parsing them as language tokens, which is an indirect and inefficient way to absorb a visual pattern. The efficiency frontier has been unforgiving. If you want cheap inference, you sacrifice accuracy. If you want accuracy, you sacrifice cost. Every model on the leaderboard until recently clustered into one of two camps, and no one had found a path that broke the tradeoff. BDH-CQ challenges this assumption by proposing something radical: reasoning doesn't need to be visible to work. The model absorbs demonstrations silently into its internal memory state, then solves problems through private iteration in hidden layers, without generating a single token of intermediate reasoning. A 150-parameter variant achieves 29.5% pass@2 on the ARC-AGI-1 benchmark at a computed cost of just $0.0007 per task, puncturing through the previous Pareto frontier and establishing a new state of the art in cost efficiency. Learning through hidden states The core insight is deceptively simple: a model's reasoning process doesn't need to match human communication. When you learn a new skill from examples, you don't narrate every observation. You absorb patterns directly i