标签：#AR

Hi all, I recently read this paper: Julien Guinot, Alain Riou, Elio Quinton, Gyorgy Fazekas. Steering dense music retrieval with open-vocabulary concept discovery. https://arxiv.org/abs/2608.08757 There is multiple model where you can get embedding from Song and Text so that you can search song by text. The challenges is when you get a result that don’t really respect your query, for example you search: - POP viola with female vocalist And as a result you usually get POP song with female vocalist because they are usually very common in you library, instead the Viola tend to disappear being uncommon. But the power of MIR isn’t exactly search to specific song even if uncommon ? Here the idea of the paper is to get the compressed embbeding layer, make it sparse again and be able to identify for some common words exactly which neuron are activated try to avoiding overlapping with other neuron. Then you can improve the value of let’s say the Viola neurons and then bring back to the compressed embbeding space. This is not mine, is only explanation, what I did is in the past a Distilled version of LAION CLAP called DCLAP that is around 7 million parameters and can efficiently run on CPU: - https://github.com/NeptuneHub/AudioMuse-AI-DCLAP The following the paper I also trained a SAE for DCLAP : - https://github.com/NeptuneHub/AudioMuse-AI-SAE So if you’re interested you can take a look at let me know. Are all free and opensource. Finally if you want to see both of them in action I used both the model for AudioMuse-AI , a software dedicated to sonic analysis and automatic playlist creation (with various model): - https://github.com/NeptuneHub/AudioMuse-AI If you have any feedback, suggestion, idea, please let me know ! submitted by /u/Old_Rock_9457 [link] [留言]

I have spent the better part of the last five years watching the relationship between developers and their tools mutate at a pace that most of us are still struggling to internalize, and if there is one pattern that repeats itself in almost every codebase I get pulled into for a review, it is this: a junior developer or a solo founder leaned heavily on an AI coding assistant to ship something functional, the thing genuinely worked in the demo, and then six weeks later the entire system started buckling under its own weight because nobody, including the AI, was thinking about architecture at the time the first line of code was written. This is not a criticism of AI tools, and it is definitely not a criticism of the people using them, because I think leaning on AI to move fast is one of the most rational decisions a resource-constrained developer can make in 2026. The problem is not the tool. The problem is that most people never learned how to ask an AI system to think architecturally, because architectural thinking was never explicitly taught to them in the first place, and AI assistants are extremely good at answering the question you asked while being completely indifferent to the question you should have asked. So this guide is my attempt to hand you the mental checklist that I use, refined over years of both writing production systems by hand and increasingly delegating large portions of that work to AI pair programmers. I am going to be deliberately thorough here rather than punchy, because the whole point of architecture is that it rewards patience and punishes shortcuts, and a survival guide that reads like a listicle would betray the subject matter. Why "vibe architecture" collapses later rather than immediately The dangerous thing about building a system with an AI assistant when you do not understand architecture yourself is that the failure mode is deferred. A missing index does not matter until your table has real data in it. A tightly coupled service do

Mithil Vakde trained a small transformer from scratch in 1.5 hours on a rented RTX 5090. The compute cost came to about 67 cents. The model scored 44% on the ARC-AGI-1 public eval, one point behind TRM's 45% and in the same band that left DeepSeek R1, o3-mini, and Gemini 2.5 Pro behind when the TRM paper ran the comparison ( arXiv 2510.04871 ). This is the third post in his ARC series. The previous result went viral and drew public scrutiny from researchers including Lucas Beyer, Jeremy Howard, and Rohan Anil. The new one raises the score, cuts the cost, and answers every objection in a long appendix. What the model does Each puzzle becomes a sequence of tokenized grids. The transformer trains on those sequences from scratch at test time, using both the train puzzles and the eval puzzle inputs, with the eval labels hidden. Test-time training is not a loophole here. ARC is a meta-learning benchmark built around skill acquisition, and Chollet's original paper frames the whole thing as a measure of how efficiently a system gains new skills ( arXiv 1911.01547 ). The architecture got a 2026 refresh: 8 layers, SwiGLU, RMSNorm, the NorMuon optimizer, 3D RoPE, and per-task embeddings. Inference augments each test input with color and dihedral permutations, inverts the augmentations, and submits the two most common outputs. The biggest change is the loss function. Previous versions trained on input and output tokens. This one trains on output tokens only, which makes the approach supervised. Score went from 40% to 44%. Vakde admits he does not fully understand why, and the training loss got worse even as scores improved. His guess is finite model capacity. The ablations back him up on what carries the result: drop the 3D RoPE and the score falls to about 24%, drop the per-task embeddings and it falls to about 24%. Representations, not compute, are doing the work. The lineage it joins None of these systems pretrain. They learn from the benchmark's roughly thousand examples: S

Every time I tried to explain technical debt to a business leader early in my career, I watched their eyes glaze over at roughly the same word. I would talk about coupling, legacy modules, and refactoring, and they would hear a developer asking for time to tidy up code that already worked. From where they sat, it sounded like a hobby. The system ran, customers paid, revenue arrived. Why would anyone spend money making invisible internals prettier when there were features to ship and deadlines to hit? The breakthrough, for me, was to stop explaining the engineering and start describing the finance, because technical debt is a loan whether anyone chose to take it or not. Every time we shipped a shortcut to hit a date, we borrowed speed today against effort tomorrow. That is often a completely rational trade. Getting to market fast can be worth far more than a clean design nobody ever sees. The problem is not the borrowing. The problem is that this loan accrues interest silently, and the business had been making payments for years without ever seeing the statement. That interest shows up in ways leaders actually feel, once you connect the dots for them. It is why a feature that used to take a week now takes a month. It is why every change risks breaking something unrelated, so nothing ships without a nervous weekend. It is why new hires take half a year to become productive in a codebase that only its veterans can navigate. None of that reads as "debt" on any report, but it is the compounding cost of shortcuts taken long ago, paid daily by everyone who touches the system. Framed that way, the conversation finally changes. I stop asking for permission to clean things up and start presenting a financial choice. We can keep paying this interest indefinitely and watch our delivery speed keep bleeding out, or we can pay down some principal now and get that velocity back. Sometimes the honest answer is to keep carrying the debt, and that is fine. What is not fine is carrying

developer context switching security DevSecOps flow state developer velocity security alerts batch security patching ROI cost of context switching developer productivity security security alert fatigue developer cognitive load ad-hoc security patching interrupting developer flow engineering vp productivity metrics DevSecOps velocity context switching recovery time 23 minute recovery context switch batching security alerts SLA-backed fix campaigns security SLA for developers minimizing context switching feature delivery vs security developer experience DevSecOps The Real Cost of Context Switching What Security Alerts Actually Do to Developer Flow Back to blog What interruptions actually cost Is it worse for developers specifically? The research says probably yes The alert volume isn't imaginary — but be careful which numbers you cite The fix: batch the routine work, protect the calendar The important exception: not everything can wait for the batch A more honest way to estimate the ROI The takeaway Sources The Real Cost of Context Switching: What Security Alerts Actually Do to Developer Flow Companies keep investing in better frameworks, tighter deployment gates, and broader platform suites — and feature delivery keeps getting slower anyway. For engineering leaders trying to explain that paradox to the board, the usual suspects (headcount, tooling, talent) rarely hold up. The more useful place to look is something less visible: how often developers get pulled out of what they're doing, and what it costs them to get back in. As "shift-left" security practices spread, developers absorb a steady stream of vulnerability alerts, automated pull-request comments, and one-off Jira tickets throughout the day. The goal — a more secure codebase — is the right one. The delivery mechanism is often the problem. Scattering fixes across random moments in the workday erodes productivity without necessarily making the codebase safer any faster. The alternative a growing number of engi

iRobot has announced a new flagship robot vacuum, which it will showcase at IFA in Berlin this week, the company's first big tech trade show in years. The Roomba maker will be exhibiting under its new owner, Picea Robotics, the contract manufacturer that purchased the once-troubled American robotics company out of bankruptcy in January. The […]

Have you ever read a job posting and your heart just sings the song of "HIRE ME PLEASE!!!", yeah,...

Why did I sign up to review when it’s not reciprocal? Am I an idiot? Am I dumb to sacrifice some of my precious time outside of work to review these papers when I don’t even have to? Yes. I tell myself I’m giving something to the community. But all I’m really doing is pissing off the authors as I reject their papers. I really wanted to accept one of them too. But, it wasn’t as well done as I’d hoped. Strong reject. Nobody made me sign up. Nobody even asked me personally. They sent a lovely form email that goes to everyone who’s published there. I let feeling important convince me to do it. How dumb of me! At least it’s only a couple of papers and a small amount of my time. And I’m learning something new reading stuff slightly outside my direct field, that I would never normally read otherwise. And I get to hone the skill of critical reading, thinking, and generally understanding how a paper should (or should not) be put together. Maybe it was a good idea after all. How does everyone else feel about non-reciprocal reviewing? I imagine those that agree to do it are in the minority. submitted by /u/OptimalOptimizer [link] [留言]

These articles come from lessons learned while building Eterna Clarity and the operating system I use to run it. Some of the most misleading moments in building software happen when the page looks finished. The button is there. The layout is polished. The flow works in a test account. The code has been merged. It is very easy to look at that and think the product has moved forward. Then production reminds you that a product is larger than its frontend. I learned this repeatedly while building Eterna Clarity. A customer-facing change could depend on application code, a database function, authentication, storage rules, an email template, environment configuration and the way a demo account was isolated from real customer data. If one of those pieces stayed behind, the screenshot could be correct while the product was not. That changed the way I think about releases. A release is not “the code shipped.” A release is the smallest complete set of owned systems that have to advance together for the accepted behavior to become true in production. The browser can hide a lot of unfinished work Frontend work is unusually visible. That makes it easy to use as a proxy for progress. Back-end state is less visible. So are permissions, production configuration, storage policy, transactional email, tenant boundaries and data migrations. They tend to reveal themselves only when something goes wrong. That asymmetry can create a strange kind of false confidence. A team can spend hours polishing the thing a customer sees while the systems underneath it still describe an older product. In Eterna, the correction was to stop treating the repository as the whole release. Source code still matters. It is simply one owner among several. If a new customer flow requires a database change, the production database has to advance. If it requires a new authentication behavior, the production auth configuration has to advance. If it depends on storage permissions, those permissions have to exist in

Please post your personal projects, startups, product placements, collaboration needs, blogs etc. Please mention the payment and pricing requirements for products and services. Please do not post link shorteners, link aggregator websites , or auto-subscribe links. -- Any abuse of trust will lead to bans. Encourage others who create new posts for questions to post here instead! Thread will stay alive until next one so keep posting after the date in the title. -- Meta: This is an experiment. If the community doesnt like this, we will cancel it. This is to encourage those in the community to promote their work by not spamming the main threads. submitted by /u/AutoModerator [link] [留言]

What’s up everyone. My name is Theodore Ochsen, founder of DaemonCore. I’ve been a developer for well over a decade, and my background goes back to running three PC repair shops before eventually moving heavily into software development, cybersecurity and building applications with my team. My road here has been anything but normal. A serious auto accident in 2015 basically nuked the life I had built. I lost the shops, lost my ability to walk and spent almost three years in rehab learning to walk again. Eventually I lost my marriage, my home and ended up in a wheelchair with pretty much one thing I could still do: code. I used to park myself at Barnes & Noble and read programming books for hours because I couldnt afford to buy all the damn things. Then I'd go back and try what I learned. I just kept building. In 2022 I went back to school for Forensic Psychology with a focus on cybercrime, and I graduate with my BA next month. At the same time, DaemonCore has grown into a team building software, security tools and some weird shit that occasionally starts as “what if we tried this?” and somehow becomes an actual product. One of our newest projects is DaemonCore Academy, which we started building last September and finally launched publicly about a week ago. The concept is pretty simple: cybersecurity education should be hands-on and the knowledge should be free. No three lessons followed by a credit-card screen. We start with fundamentals and work toward hands-on drills and environments where people can actually experiment, break things legally, understand WHY they broke, reset and try again. I'm joining DEV because I dont just want to drop links and disappear. I want to talk development. Architecture, Android, React, databases, security, stupid bugs that steal six hours of your life, things we've learned the hard way, and probably a few things we'll get completely fucking wrong and learn from publicly. I’ve spent enough years doing this to know one thing for certain

If you approach generative models as ""networks that create images,"" the field quickly turns into a collection of disconnected architectures. A more useful developer mental model starts one level lower: What probability structure could have produced the data, and how can we represent, learn, and infer that structure without making the computation impossible? That question connects autoregressive models, VAEs, flow-based models, GANs, and diffusion models. Their architectures look very different, but they all respond to the same underlying tension: high-dimensional data distributions are difficult to represent, learn, normalize, sample from, and reason about. Generative modeling can therefore be organized around three interacting problems: Representation: How do we represent a complex high-dimensional joint distribution? Learning: How do we make the model distribution approach the data distribution? Inference: Given an observation, how do we reason backward about hidden variables or the process that generated it? Once these three pieces are connected, the major families of deep generative models become much easier to understand. From prediction to distribution learning A discriminative model usually begins with a prediction problem. Given an input x , predict the most likely output y : f ( x ) = y ar g max ​ p ( y ∣ x ) The model focuses directly on the conditional relationship required for prediction. A generative model asks a broader question. Instead of learning only the path from x to y , it models the probability structure from which the data arises. For class-conditional modeling, for example, we can model p ( x ∣ y ) together with the prior p ( y ) and recover the posterior using Bayes' rule: p ( y ∣ x ) = p ( x ) p ( x ∣ y ) p ( y ) ​ In unsupervised generative modeling, the target becomes the data distribution itself. We assume the training samples come from some unknown distribution: x 1 ​ , x 2 ​ , … , x N ​ ∼ i.i.d. p data ​ ( x ) The model then construc

Originally published on tamiz.pro . We have collectively lost our minds over benchmarks. AgenticBench scores 90%? Great. Multi-Agent Hallucination Leaderboard rank #1? Impressive. Yet the moment you ship that same agent to a chaotic production environment with 14,000 SQL dialects, flaky APIs, and users who refuse to follow instructions, it collapses within hours. This is not a bug. It is a feature of how we evaluate these systems. The gap between benchmark performance and production reliability is the single most dangerous illusion in current AI engineering. Benchmarks measure capability ; production measures consequence . If you are building AI agents today, you are likely flying blind. Here is why your evaluation strategy is lying to you, and what actually happens when agents hit the wire. The Snapshot Fallacy Benchmarks are snapshots. They are static, curated, and deterministic. An agent tasked with answering a question from Wikipedia is doing retrieval and generation. In production, that same agent might be triggering a refund API while concurrently writing to a database. The problem is that benchmarks rarely account for statefulness . A chatbot that generates a perfect summary is qualitatively different from an agent that executes a five-step workflow where Step 3 depends on the output of Step 1, which was corrupted by a non-deterministic tool response in Step 2. Benchmarks usually test the trajectory in isolation. They do not test the persistence of the state across 10,000 concurrent requests. When you move from benchmark to production, you introduce temporal decay . The model context window fills. Tool schemas drift because the upstream API changed yesterday. Database schemas evolve. The agent you tested in January is functionally a different entity in June, yet your evaluation suite remains frozen in time. The Tooling Cliff The most common failure mode in production agents is not hallucination—it is tool failure . In a benchmark, if you ask an LLM to get_wea

Originally published on hexisteme notes . I run a video pipeline where every shot carries a contract: a must_have list, a must_not_have list, and a serves_line field — the narration line the shot exists to support. One rule in that pipeline, which I call the enactment rule, checks each contract for self-contradiction: if must_not_have forbids the very thing serves_line requires, the shot can't honor its own contract and support its sentence at the same time, so the rule fails it hard at author time. It's a good rule to want. It had never once run. One layer deeper than the usual dead gate This adds another entry to the same line of investigation: Grep won't find your dead gates. A fill-rate query will. found rules nobody was calling — the wiring itself was absent; The Guard Passed on an Empty Table found a correctly-called rule whose target population was empty at runtime, so it passed on nothing left to check; and The check that cannot fire found a rule that ran against real data and silently disabled itself because its threshold was an absolute constant that didn't match the input's scale. This one sits a layer deeper than all three: the callers existed, the rule fired on every invocation, and what was actually missing was a producer for the one field the rule needed to read. The field nothing writes serves_line is a derived field — by definition, it's the narration of the beat the shot is attached to. I checked that derivation against reality before touching anything else: every stored value that existed matched its beat's narration exactly, 6 of 6, zero drift. Wherever the field existed, it was right. But almost nowhere did it exist. A repo-wide search for anything that writes serves_line returned zero producers. The archetype templates that generate contracts don't set it. So every contract created through the supported authoring path had serves_line = None , and the rule — which needs that field as its input — silently evaluated nothing. A published episode ha

333 miles of real-world range with uncompromised comfort and off-road ability.

After long delays, JLR’s biggest gamble with its Range Rover brand is here with huge performance, range, and off-road EV skills. It’s mighty pricey, but the US gets a cheaper model.

You're just a few taps away from getting your Android phone out of safe mode and back to normal.

JioHotstar will only have entertainment content when it launches in the UK, Canada, and Singapore.

Originally published on indiecore.net . I moved this site off a hosted blogging platform onto Cloudflare, with GitHub Actions doing the building and Cloudflare doing the serving. It costs nothing, deploys in about two and a half minutes, and refuses to publish anything that fails its checks. Getting there took longer than it should have. Here is the setup, and the five things that tripped me up — none of which are obvious from the documentation. The shape of it git push └─ GitHub Actions ├─ build generate the site ├─ verify dead links, missing images, bad metadata, broken redirects ├─ Lighthouse fail if performance/accessibility/SEO drop below budget └─ deploy upload to Cloudflare The important part is that deploy depends on the checks . A broken build never reaches the internet. Pull requests get a preview URL; merges to main go live. The triggers and permissions that make that safe: ci-cd.yml — triggers and permissions name : CI/CD # Build and verify every change; deploy previews for PRs and production from main. # Deploy jobs depend on the quality gates, so nothing ships unverified. on : push : branches : [ main ] # The SEO watch ledger is machine-written, is never part of dist/, and is # committed daily. Deploying the site again for it would be pure noise — and # would re-trigger the SEO ping through workflow_run every single day. paths-ignore : - ' _source/seo-watch.json' pull_request : branches : [ main ] workflow_dispatch : # Least privilege by default; individual jobs elevate only what they need. permissions : contents : read # Supersede in-flight runs for a branch, but never interrupt a production deploy. concurrency : group : ci-cd-${{ github.ref }} cancel-in-progress : ${{ github.ref != 'refs/heads/main' }} env : # wrangler ships as a pinned devDependency; never phone home from CI WRANGLER_SEND_METRICS : " false" permissions: contents: read at the top means every job starts with the minimum, and only the one that comments on pull requests gets more. The c

Short answer: for a property-management startup, the cheapest one-key router is the one that minimizes cost per correctly classified moderation report on your own replay set while preserving a provider-neutral request, response, and error contract. Raw token rates alone cannot make that choice. Choice Best fit Main catch Measure first Managed multi-provider router Small team optimizing time-to-first-call Another control plane owns the routing boundary Valid classifications per dollar Self-hosted gateway Team that needs policy and telemetry under its control You own upgrades, capacity, and incident response Operator hours plus inference cost Thin in-app adapters Narrow model set and strict contract control Every new capability adds adapter work Change lead time and test burden My default for an early startup app is a managed router behind a tiny internal interface, with request fixtures stored outside the router. Choose the self-hosted runner-up when data-path control or custom routing policy is more important than low configuration overhead. Choose direct adapters when the application genuinely uses only a small, stable slice of each provider API. This is a decision about portability, not a hunt for a permanent lowest price. OpenAI, Claude, and Gemini differ in message shapes, structured-output behavior, usage accounting, and model lifecycle. A shared API key removes credential sprawl; it doesn't erase those differences. How should a startup app compare token cost across one-key routers? Start with the unit of work: one moderation report reaching a human reviewer with a valid label, confidence, rationale, and trace ID. A property manager does not buy tokens for their own sake. They need reports such as harassment , fraud , safety , or noise triaged consistently enough that urgent cases rise and ambiguous cases stay in the human queue. The useful equation is: effective cost = inference charges + router charges + retries + invalid-output handling + operational labor T