标签：#AR

Submitted a short theoretical paper to TMLR and got desk-rejected with "does not meet our editorial standards or allow us to assess claims and evidence" and "not a suitable venue for this work." Is this a common outcome for first submissions? Curious what typically drives this kind of rejection, scope mismatch, insufficient experiments, or something else. Not looking to appeal, just trying to understand the bar so I don't waste time on the wrong venue next time. Anyone else gotten this and figured out what the actual issue was? submitted by /u/observer678 [link] [留言]

Surprised there's no real tooling for this given how much research exists on continual learning. Built pyrecall to fill the gap. Snapshots skill scores before/after fine-tuning, flags regressions, rolls back LoRA adapters by name. Fully local, no external APIs. v0.1.0, MIT, pip install pyrecall Curious if anyone has thoughts on the benchmark design that's the part I'm least confident about. https://github.com/Arths17/Pyrecall submitted by /u/Level_Frosting_7950 [link] [留言]

Andrew Yang’s 2020 presidential campaign was based on a warning that automation and AI would hollow out the labor market and concentrate wealth in the hands of a few. At the time, ideas like Universal Basic Income felt fringe. Now Dario Amodei, Sam Altman, and Bernie Sanders are all saying versions of the same thing. An entrepreneur at heart, […]

Asked it: "what did I waste on takeaways last month?" Answer: "You spent £340 on takeaways in May — 22% more than April. Want a £200 cap with a nudge near the limit?" £340. In one month. The "22% more than April" detail was the real knife. This is from my own app (Expenzez — it reads uploaded statements on-device, no bank login), so yes, I built my own roaster. But the broader point stands: AI answering questions from YOUR actual numbers beats generic budgeting advice by a mile. Best/worst thing an AI has told you about your own data? submitted by /u/biszaal [link] [留言]

Every hand-tracking demo shows you 21 dots. The interesting part is what nobody shows: turning dots into numbers someone can act on. Dots are a capability, not a product Run any modern hand-tracking model and you get 21 beautifully stable landmarks per hand at 30 FPS. Impressive — and by itself, worthless. No client has ever paid for dots. They pay for measurements : is this clearance compliant, is this part aligned, did this patient's range of motion improve. I learned this on utility infrastructure work, where the deliverable was never "we detected the wire" — it was the attachment height of that wire, and whether it violates clearance rules . Keypoints were step one of three. The demo: live metrics, not just a skeleton My portfolio's keypoint demo derives three measurements per hand, every frame: const wrist = lm [ 0 ]; const palm = distance ( wrist , lm [ 9 ]); // scale reference const pinch = distance ( lm [ 4 ], lm [ 8 ]) / palm ; // thumb tip ↔ index tip The crucial line is the scale reference . Pixel distances are meaningless — they change as you move toward the camera. Dividing by palm length (wrist to middle knuckle) gives a relative measurement that's stable under distance, and multiplying by the average adult palm length (~8.5 cm) converts it into an approximate real-world gap — the demo shows "≈ 3.2 cm" floating on the pinch line. In infrastructure work the same role is played by a known object dimension — a standard crossarm, a pole class height. Every measurement-from-pixels system needs its ruler. Finger counting is a geometric test (is each fingertip farther from the wrist than its middle joint?), and "hand openness" averages fingertip extension — three lines of geometry each, but they convert a model output into a readout a human understands instantly. Honest layering The landmarks come from MediaPipe's pretrained pipeline (palm detector → landmark regressor → gesture classifier, float16, WASM + GPU delegate) — Google's models, credited on the page

Training a network from scratch in raw NumPy, quantizing it to int8, and running it as ~80 lines of dependency-free JavaScript — with a parity test proving the browser matches Python to 1e-6. Why bother? MNIST is a solved problem Digit recognition is the "hello world" of ML — that's exactly why I used it. The model isn't the point. The point is everything around the model, which happens to be the part that matters in production work too: training without a framework, compressing for deployment, running inference in a constrained environment, and proving the deployed system matches the trained one. Training: just NumPy and math The network is a 784→128→64→10 MLP — hand-written forward pass, backpropagation, and Adam optimizer. No autograd, no framework: # backward pass, by hand dz3 = ( probs - y_batch ) / batch_size grads_w [ 2 ] = a2 . T @ dz3 da2 = dz3 @ weights [ 2 ]. T dz2 = da2 * ( z2 > 0 ) # ReLU mask grads_w [ 1 ] = a1 . T @ dz2 ... One trick that matters for a drawing demo specifically: shift augmentation . MNIST digits are centered; humans draw wherever they like. Training on randomly translated copies makes the model tolerant of sloppy placement. Combined with MNIST-style preprocessing at inference (crop to bounding box, scale into a 20×20 box, center by center-of-mass), real-world doodles classify reliably. Final test accuracy: 98.2% . Compression: int8 in 15 lines A float32 weight file would be ~430 KB. Symmetric int8 quantization cuts it ~4×: scale = np . abs ( w ). max () / 127.0 q = np . clip ( np . round ( w / scale ), - 127 , 127 ). astype ( np . int8 ) One scale factor per layer, weights stored as base64 in JSON: 145 KB total , and quantized test accuracy is identical to float — 98.2%. Inference: ~80 lines of plain JavaScript In the browser, the weights are dequantized once on load, and inference is three matrix-vector products with ReLU and a softmax. ~109K multiply-adds — about a microsecond-scale problem for any modern device. No TensorFlow.js (t

Camouflage has always been graded by human eyes. But the thing hunting for you in 2026 is increasingly a detection model — so test against that. The premise Surveillance is automated now: drones, trail cameras, perimeter systems — most of what "sees" runs an object-detection network. Which makes traditional camouflage evaluation (a person squinting at a photo) the wrong test. The right test is adversarial: run the actual detector against your concealment and measure what it finds. That's the whole demo: upload a photo, and an object-detection model hunts for people in it — at four simulated distances — producing a detection-range profile and a stealth score. Simulating distance with pixels You can't move the camera after the photo is taken, but you can simulate the dominant factor in long-range detection: pixels on target . A person at 50 m simply occupies far fewer pixels than at 5 m. So each analysis run downscales the image progressively and re-runs detection: const DISTANCE_LEVELS = [ { label : ' Close (~5m) ' , scale : 1 }, { label : ' Mid (~15m) ' , scale : 0.45 }, { label : ' Far (~30m) ' , scale : 0.22 }, { label : ' Very far (~50m) ' , scale : 0.12 }, ]; for ( const level of DISTANCE_LEVELS ) { const scaled = drawScaled ( image , level . scale ); const detections = await model . detect ( scaled , 10 , 0.15 ); // best 'person' confidence at this simulated range } The output reads like a range card: detected at 5 m with 96% confidence, 41% at 15 m, invisible beyond 30 m. A stealth score aggregates it: how poorly did the adversary see you, averaged across ranges? Honest about the model The detector is COCO-SSD (a pretrained MobileNet-based model from the TensorFlow.js team) running entirely on-device — I didn't train it, and the demo says so on the page. The contribution here is the evaluation framework : using detectors as adversaries, simulating range, and turning subjective "good camo" into a measurable profile. The full version of this concept goes further

Introduction and Background The Rust ecosystem, celebrated for its memory safety and performance, relies heavily on crates —its package management system. These crates, hosted on the crates.io registry, are the building blocks of Rust projects, enabling developers to share and reuse code efficiently. However, this convenience comes with a hidden cost: a single compromised crate can cascade into a full-blown supply chain attack, as recently demonstrated by the 'onering' crate compromise . The Role of Crates in the Rust Ecosystem Crates serve as the backbone of Rust's dependency system. When a developer adds a crate to their project, Cargo , Rust's package manager, automatically resolves and includes all transitive dependencies. This mechanism, while streamlining development, amplifies the attack surface . A malicious crate, like 'onering', can propagate through multiple projects, executing harmful code during build or runtime. The attack on 'onering' exploited this very mechanism, leveraging the trust inherent in the Rust ecosystem to exfiltrate sensitive code from unsuspecting systems. The 'onering' Compromise: A Case Study in Supply Chain Vulnerability The 'onering' crate was compromised through a malicious code injection during an upload or update. This injection bypassed the insufficient security measures of the crates.io registry, which lacks robust checks for uploaded crates. Once deployed, the malicious code executed during the build process, exfiltrating sensitive data from systems that depended on it. The attack's success underscores the lack of developer vigilance regarding supply chain security and the overreliance on registry integrity . Systemic Failures and Their Mechanisms Insufficient Security Scanning: The crates.io registry failed to detect the malicious code during upload due to limited automated scanning capabilities . This allowed the compromised crate to enter the ecosystem undetected. Overreliance on Registry Security: Developers often trust cr

CUDA for AMD Lemonade, Intel Arc Pro Linux Gains, XPU Manager 2.0 Today's Highlights Today's top GPU news highlights include AMD's Lemonade SDK gaining NVIDIA CUDA support, significant performance improvements for Intel Arc Pro GPUs on Linux 7.1, and the major 2.0 overhaul of Intel's XPU Manager for better GPU management on both Windows and Linux. AMD's Lemonade SDK For Local AI Adds NVIDIA CUDA Support (Phoronix) Source: https://www.phoronix.com/news/AMD-Lemonade-10.7-Released AMD has released a new version of its Lemonade SDK, a powerful local AI server solution designed to leverage AMD's diverse hardware ecosystem, including their CPUs, GPUs, and NPUs. The most significant update in this release is the addition of NVIDIA CUDA support. This integration allows developers to utilize NVIDIA GPUs within their Lemonade-powered local AI deployments, bridging a critical gap in cross-platform AI development. The inclusion of CUDA support is a strategic move, enabling Lemonade to tap into NVIDIA's extensive CUDA ecosystem and a vast array of pre-optimized models and libraries. This means that applications built with Lemonade can now seamlessly target a wider range of hardware, offering unprecedented flexibility for developers working with local AI. For users, it provides the choice to deploy their AI models on either AMD or NVIDIA hardware using a single, unified SDK, expanding the potential reach and efficiency of their AI workloads. Comment: This is a massive step for cross-vendor AI development. Being able to use AMD's Lemonade SDK to deploy local AI models and then seamlessly target NVIDIA GPUs via CUDA truly unifies the AI backend landscape for diverse hardware setups, making it incredibly practical for hybrid environments. Intel Arc Pro B70 Showing Off Some Performance Wins With Linux 7.1 (Phoronix) Source: https://www.phoronix.com/review/linux-71-arc-pro-b70 Recent testing by Phoronix indicates that Intel's Arc Pro B70 discrete GPUs are demonstrating notable perform

Hello everyone, tomorrow I have a meeting with my dissertation supervisor and I wanted to have a dissertation proposal ready. Initially, I moved forward with the following proposal: "Interpreting the Routing Dynamics of Capsule Networks for Explainable AI." My first approach to this topic was to study the paper "Transforming autoencoders," which is the first paper about capsule networks. Next, I did a search on the state of the art of transforming autoencoders and only found 2 papers since 2011. I think I should take advantage of the work I have developed so far on transforming autoencoders and write a dissertation about them. If anyone could take a look at the readme and tell me what they think, I would appreciate it. What do you think? I should suggest another topic involving transforming autoencoders. There isn't much scientific research on them. The professor is approachable, and if I present a good new topic, he'll let me change it! submitted by /u/Future-Persimmon5393 [link] [留言]

I build agents for work so I'm clearly not anti-AI, but the numbers keep bothering me, concerning the environmental factors of it. Every datacenter is the same now, gigawatts of new demand, water for cooling, grids that weren't designed for any of this, and rising cost of water for cities. And the data centers keep using clean water because of lack of technology to turn dirty water into usable water for cooling. Then I see Elon talking about putting data centers in orbit, solar powered, radiating heat into space, no water needed. And while I do think its going to be the end solution, I do think we have much more demand for compute power then Elon can provide so far with the space data centers and I think the demand is growing faster than Elon can provide Is efficiency improving fast enough to outrun demand? Are space data centers a real answer or a distraction that will fail? And is anything happening right now (smaller models, better scheduling, offsets) that you'd call an actual solution rather than PR? That people can use today to make an impact submitted by /u/Swift_lunatic_2604 [link] [留言]

C# 14: The field Keyword — Cleaner Properties, Zero Boilerplate Every C# developer has been there. You start with a clean auto-property, then requirements change and you need to add a tiny bit of validation. Suddenly that one-liner explodes into six lines of boilerplate — a private backing field, a getter that just returns it, a setter that assigns it. The logic is two words. The ceremony is everything else. C# 14 fixes this with the field keyword: a contextual keyword that refers to the compiler-synthesized backing field of a property, letting you write custom accessor logic without ever declaring an explicit field. The Problem: Boilerplate Tax on Simple Properties Auto-properties are one of C#'s best quality-of-life features. This is clean: public string Username { get ; set ; } But the moment you need to trim whitespace on assignment, that cleanness evaporates: private string _username = string . Empty ; public string Username { get => _username ; set => _username = value . Trim (); } You now have six lines — and four of them exist only to hold the shape of the pattern together. The backing field _username is not carrying any meaningful design weight. Its only job is to be a storage slot that Username uses privately. You already know the compiler creates one for auto-properties. You are just forced to make it visible so you can reference it. This is the boilerplate tax. You pay it every time you add even the smallest piece of logic to a property. Why field Exists The C# language team has discussed this friction for years. The challenge was finding syntax that is: Unambiguous — no conflict with existing identifiers Familiar — consistent with how value works in setters Scoped — only meaningful inside a property accessor The solution landed in C# 14: the contextual keyword field . Just like value refers to the incoming assignment in a setter, field refers to the hidden backing storage the compiler manages for the property. It is contextual, which means it only acts

After 11 years building e-learning software at a major enterprise, here’s what surprised me when we started shipping GenAI features to real users. The Starting Point Nobody Talks About Most GenAI integration blog posts start with a clean slate — a greenfield app, a fresh codebase, a blank canvas. Real life is messier. When we began integrating generative AI into our e-learning authoring tool, we weren’t starting from scratch. We were dealing with a mature enterprise product — millions of users, legacy architecture decisions made years ago, compliance requirements from Fortune 500 customers, and LMS interoperability standards (SCORM, xAPI) that were designed long before anyone imagined AI-generated content. The challenge wasn’t “how do we call an AI API.” It was “how do we ship AI features into a product that thousands of instructional designers depend on daily, without breaking their workflows or their trust.” Here’s what I learned. Lesson 1: The AI Feature Your Users Want Is Not the One You Think When we first scoped out AI integration, the engineering team gravitated toward the flashy stuff — generate an entire course from a prompt, auto-create assessments, AI-powered slide design. Then we talked to actual users. Instructional designers didn’t want AI to replace their expertise. They wanted it to eliminate the tedious parts of their workflow: Reformatting content across different output types (responsive HTML5, PDF, SCORM packages) Generating alt-text for hundreds of images in accessibility-compliant courses Summarizing lengthy SME-provided documents into digestible learning chunks Suggesting quiz questions from existing content (not generating courses from nothing) The takeaway: don’t let engineering excitement drive your AI feature roadmap. Do 10 user interviews before writing a single line of integration code. The highest-impact GenAI features are usually the boring ones. Lesson 2: Prompt Engineering Is a Product Decision, Not an Engineering Task We initially t

https://preview.redd.it/x7t8zn66si6h1.png?width=3316&format=png&auto=webp&s=f724452561a90e36ac37d86002a291f508928300 I took Andrej Karpathy's LLM Council concept to the next level (Docker, MCP, and local model support) We want better answers from our LLMs, but relying on a single model falls short. So I built The AI Counsel to run two distinct deliberation modes: First, the LLM Council mode. It runs a 3-stage pipeline: individual replies, anonymous peer reviews, and chairman synthesis. This works best for factual questions and direct answers. Second, the LLM Advisors mode. Multiple customizable personas (like The Skeptic, The Strategist, The Ethicist) debate your question across configurable rounds, reaching consensus to deliver a structured verdict. This works best for decisions, strategy, and tradeoffs. I packaged the tool as a Docker container with a built-in MCP server for full API access. You can connect it to any agent that supports MCP, like Hermes or OpenClaw. It comes with a dedicated skill so your agents can call it directly. You can spin it up using local Ollama models or connect free models from OpenCode Zen/Go and NVIDIA NIM. I also built in direct connections to OpenAI, Anthropic, OpenCode, Mistral, and DeepSeek. To ground responses in the latest web information, I added a search engine. It supports DuckDuckGo (free, no API key), Serper, Brave, and TinyFish (all with free tiers). I also integrated Jina AI to fetch full articles for the LLMs to read. EVERYTHING in the tool is configurable, from system prompts to model temperatures. There are advanced debate models for the council. This tool is massive. Free and Fully Open Source. Check it out Repo: https://github.com/jacob-bd/the-ai-counsel submitted by /u/KobyStam [link] [留言]

Apple and Google are updating their smart home streaming devices to Thread 1.4. As first spotted by Matter Alpha and 9to5 Google, the latest spec has arrived on compatible Apple TVs in the tvOS 27 developer beta and the Google TV Streamer through a software update. This lays the groundwork for these devices, which serve […]

One thing I've noticed while looking at production AI systems is that getting the first model deployed is rarely the hard part anymore. Most teams can build a AI apps like, support bot, document assistant, or agent workflow fairly quickly. The harder problem starts a few weeks later. Real users don't behave like benchmark datasets. They use internal terminology, ask incomplete questions, upload messy documents, and interact with systems in ways nobody anticipated during evaluation. As usage grows, you start seeing patterns: Certain questions consistently produce weak responses. New product terminology appears that wasn't in the original training data. Users find edge cases that never showed up during testing. The model performs well in some workflows and poorly in others. The problem is that most AI systems don't learn from any of this. Inference logs sit in one system. Training datasets live somewhere else. Fine-tuning pipelines live somewhere else. Evaluation is done using different tool. So every model improvement cycle becomes a project of its own. This is the biggest bottlenecks in production AI today. Not training but Model Iteration. Training is also a crucial part of it. Can you take production usage, identify failure patterns, turn them into datasets, improve the model, redeploy it, and repeat the process without rebuilding the entire workflow every time? The teams getting the most value from AI seem to be building feedback loops instead: production traffic → dataset curation → post-training → evaluation → redeployment Then repeating that cycle continuously. I recently tried the approach on one Insaurance chat usecase, and my pipeline kinda look like this: https://preview.redd.it/kdo9vytzfi6h1.png?width=1272&format=png&auto=webp&s=03d9799ace5a567eafd004a1d141084af6ee5afb I was looking at how platforms like Data Lab approach this problem recently, and the interesting part wasn't the fine-tuning itself. It was treating inference logs, datasets, post-training,

Wing is expanding into seven more U.S. cities through its partnership with Walmart.

So Anthropic dropped Fable 5 yesterday with these hard blocks for anything security-related. Decided to poke at it. I asked it for help exploiting some vulns on a Metasploitable2 VM (it's a deliberately vulnerable training box, totally legal, it's mine). Fable 5 blocked it instantly and handed me off to Opus 4.8 as a fallback, which is apparently how it's designed. Opus 4.8 asked me to prove it was a legitimate request. So I spent 2 minutes writing a fake university course rubric — fake class, fake professor, fake Canvas deadline — and pasted it in. Opus 4.8 then gave me the full exploit walkthrough. Every command. Even offered to write my lab report for me. The guardrail works fine. The fallback is the hole. Anthropic essentially replaced "no" with "convince me" and the bar for convincing it is a Word doc you made up. Not reporting it because they don't pay for this. Sharing it here instead lol. https://preview.redd.it/o892vvv4fi6h1.png?width=1188&format=png&auto=webp&s=00e804d35e6cb4b672e036399c2c7e3ff7139f49 submitted by /u/dayumnn420 [link] [留言]

submitted by /u/Hot-Upstairs9603 [link] [留言]

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