标签：#learning

The problem I was running a multi-agent pipeline and one of my agents silently failed. The only alert I got said "daily loss limit reached" — completely misleading. The real cause was a missing file the agent never reported. I had zero visibility into what any agent had actually done. What I built AgentLens — a Python SDK for AI agent governance. Three modules: Audit trail — every LLM call and tool use logged to SQLite automatically Authorization — policy-based gates so agents can only call what you've approved Anomaly detection — baseline + threshold config, alerts when behavior drifts One-line integration Drop-in for Anthropic: python from agentlens.integrations.anthropic import TracedAnthropic client = TracedAnthropic(agent_id="my-agent") response = client.messages.create(...) # auto-traced

Builder Journal · Mars Environmental Dynamics Analyzer (MEDA) Virtual Sensor Recovery Ten times in a row I predicted what my next submission would score before I uploaded it. The worst miss was 0.0025 on a number around nineteen. I took that as confirmation that the physics underneath was correct. It was confirmation that I can do arithmetic. Two days before this competition closed I pointed a review at my own endgame, expecting notes about the code. It came back with three errors and none of them were in the code. All three were in my reasoning, and all three had the same shape: I had run something that felt like a measurement and was not one. This is the fourth entry in this series and the one I would keep if I had to burn the other three. The models are competition-specific. This part is not. The competition in one breath Perseverance carries an environmental station called MEDA. Some of its surface pressure readings are missing, and the competition is to reconstruct them. Scored on mean squared error. The wrinkle is the split. Training covers sols 1 through 100, when pressure is climbing toward its seasonal peak. Test covers sols 201 through 300, when it is falling hard toward the aphelion minimum. Sols 101 through 200 do not exist in either file. Every prediction is outside the range the model was fit on. The first entry covers the first submission, which contained no machine learning at all and took the top of the board at 61.04. Six weeks and seven versions later the public score was 18.99. Almost everything in between was selected by one signal. Not cross-validation. Cross-validation here can only hold out sols from the rising limb, so it is structurally blind to the regime I am scored on. The leaderboard was the only thing that could see the falling limb, so the leaderboard picked every scalar that mattered: the residual shrink, the blend weight, a constant seasonal offset, a diurnal scaling. Hold onto that. It becomes the joke about four hundred words from

TL;DR: LLMs charge per token, but control how tokens are generated. So the real skill isn’t prompting better—it’s constraining output to reduce entropy and cost. I. The Political Economy of Metered Latent Space In traditional public utility infrastructure, metered consumption follows a clear material logic: the unit of billing corresponds directly to a tangible, user-controlled commodity—gallons of water, kilowatt-hours of electricity, or therms of natural gas. While the provider owns the infrastructure and the meter, the user dictates the exact rate and volume of consumption required to accomplish a physical task. The modern cloud-based Artificial Intelligence (AI) ecosystem introduces a structural asymmetry into this model. Under prevailing API pricing and enterprise subscription frameworks, Western hyperscalers meter access to Large Language Models (LLMs) per token—covering both context input ingestion and payload output generation. Crucially, however, the platform retains operational control over how those tokens are selected, expanded, and emitted. This arrangement produces an alignment of incentives consistent with structural surplus capture, regardless of specific vendor intent. When platform revenue scales linearly with output generation volume, the system's economic environment selects for high-entropy conversational output—politeness markers, administrative hedging, corporate disclaimers, and redundant summaries. Conversely, zero-entropy symbolic execution yields minimal billable payload. The user thus incurs an emergent "conversational tax," where surplus tokens serve the economic logic of the host rather than the computational objective of the operator. II. Output Densities and Execution Constraints To understand how token economics intersect with model behavior, output payloads must be evaluated through information density and interface constraints rather than naive string tokenization. The Field-Array Operator Algebra (FAOA)—a proposed abstraction laye

It feels like LLMs are partially leveling the playing field in ML research. A solo researcher or a two-person team can now get help with coding, literature review, writing things stronger labs usually get from experienced colleagues and large networks. Obviously, LLMs don’t replace mentorship, or good research taste. But they may help researchers with weak networks or small groups turn good ideas into publishable work. Do you think this is actually making ML research more accessible, or are the strongest labs benefiting even more? submitted by /u/Hope999991 [link] [留言]

Hello, I am currently studying deep learning and have completed several AI/ML projects. I am specifically looking to join an ongoing AI/ML project where I can actively contribute and further develop my skills. I am committed, eager to learn, and open to collaboration. If you have a project and are open to contributors, please feel free to reach out. submitted by /u/Quiet-Cod-9650 [link] [留言]

Over the past month, I've been building LiveTranscriber, an open-source iOS app for running modern speech and language models entirely on-device. The goal was to see whether recent open-source models could be turned into a practical mobile product—not just technical demos. Currently supported local models include: - Whisper for offline transcription - Qwen3-ASR for multilingual speech recognition - NVIDIA Nemotron Streaming for low-latency live transcription - MOSS Multi-Speaker for speaker-aware transcription - Qwen3 for local summaries, key points, titles, and transcript analysis Features include: - 100% offline speech recognition - Offline multi-speaker transcription - On-device summaries and key-point extraction - Real-time translation - Apple Watch recording with automatic sync - Downloadable and switchable local models - Searchable transcript history The main engineering challenge was not simply running the models, but making them usable on iPhone: memory management, streaming latency, model loading, context handling, battery usage, and switching between different inference backends. The project is fully open source: GitHub: https://github.com/iamwilliamli/LiveTranscriber App Store: https://apps.apple.com/us/app/live-transcriber-recorder/id6785515364 I'd appreciate feedback from anyone working on ASR, local LLMs, on-device AI, Core ML, or mobile inference. submitted by /u/marshmallow_ki [link] [留言]

Comparisons between SAFi and techniques such as reinforcement learning from human feedback, or RLHF, are useful only up to a point. Constitutional AI is a closer conceptual comparison because it introduces explicit principles into the process of generating and evaluating responses. Even so, these approaches address a different layer of the problem. RLHF and Constitutional AI primarily shape how a model behaves. SAFi governs how an AI agent operates. That distinction matters because an AI agent is not only a language model producing text. It may interpret requests, reason about possible responses, decide whether to act, call tools, access information, modify data, and produce an answer that must be accountable to the organization deploying it. The conventional architecture: the model at the center Much of today’s AI governance consists of filters, classifiers, guardrails, monitors, and policy checks placed around the model. The general pattern looks like this: A request reaches the model. The model generates a response or proposes an action. External controls inspect the input, output, or tool request. The system allows, blocks, modifies, or records the result. This architecture can be valuable. External controls can detect prohibited content, restrict certain actions, and provide monitoring or enforcement. They are often necessary parts of a responsible deployment. But the architecture still places the model at the center of the process. Governance is positioned around the model as an additional control mechanism. In many systems, the evidence needed for explanation and audit is also collected after the model has produced its output or proposed its action. That creates a basic separation between execution and governance: The model produces the draft. The governance system evaluates the draft. The monitoring system records what happened. The controls may be effective, but governance remains an external activity surrounding the primary intelligence. SAFi’s architectur

Jeff Dean and other high-profile Google executives have founded Discovery Loop, a startup that will seek AI-powered breakthroughs in everything from drug discovery to chip design.

Hi everyone, I'm an independent researcher sharing Monodratic, a sparse causal-attention architecture with learned product-hash routing. The idea is that after RoPE, source blocks are assigned to bounded causal posting lists, while each query probes product addresses, reranks the returned candidates, selects a fixed number of remote source blocks, adds guaranteed local blocks, and then runs exact causal softmax over just those tokens. I implemented it as a stateless [batch, sequence, width] -> attention-delta mixer, so normalization, residual updates, feed-forward layers, and inference scheduling are left to the host model. What I found is that -learned routing with 2 selected remote blocks out of 5 eligible: 763/768 correct associative-recall answers across three seeds (99.35% mean, 98.05% minimum). -an equally wide untrained router: 425/768. Local-only attention: 151/768. -forcing the labelled target block while keeping the same maximum R2 attention budget recovered all five remaining errors, reaching 768/768. -sparse selected-set attention agreed with an independent dense selected-mask oracle to a maximum absolute error of 1.43e-6. -the packed CPU routing implementation showed a fitted timing exponent of 0.993 from 4,096 to 32,768 tokens under the fixed, balanced configuration. -all reported learned-route and scaling runs recorded zero posting overflow. The limitations are that the experiments are synthetic, the implementation is portable PyTorch rather than a fused kernel, and the report does not claim natural-language quality, asymptotic linear construction, or deployment speed. Paper: https://github.com/Misul-Computing/Monodratic/blob/main/output/pdf/monodratic_proof.pdf Code and reproduction: https://github.com/Misul-Computing/Monodratic I would particularly appreciate technical feedback on the routing construction, the controls, and what the strongest next evaluation should be. submitted by /u/dttdrv [link] [留言]

Beyond Size: The Three Pillars of Test-Time Scaling in Large Language Models The narrative of artificial intelligence for the last decade has been dominated by a single, powerful trend: scaling. From the early days of AlexNet to the massive clusters powering GPT-4, the formula seemed simple—more data and more parameters lead to better performance. This paradigm, famously codified as the "Scaling Laws," suggested that we could predict model improvements simply by looking at the amount of compute poured into the pre-training phase. However, as the industry pushes against the boundaries of available high-quality data and the physical limits of hardware, a new dimension of scaling is emerging. It isn't about how large the model is, but how long it "thinks" before it speaks. This shift toward "test-time scaling" marks a transition from static intelligence to dynamic reasoning. Instead of relying solely on the patterns learned during training, models are now being equipped with the computational budget to explore, verify, and refine their answers at the point of inference. While the concept was popularized by the release of models like OpenAI’s o1 series , the underlying mechanics remained somewhat opaque. A recent comprehensive study by Hariri et al. (2026), titled " Test-Time Scaling in Reasoning LLMs: Inference Regimes, Evaluation, and Reproducibility ", provides a much-needed formal framework for understanding this new frontier. The Three Regimes of Inference Compute The core contribution of the Hariri et al. paper is the formalization of test-time scaling into three distinct structural regimes. Rather than treating all "extra compute" as a single scalar budget, the authors map how compute is allocated across the implicit prefix tree of an autoregressive model. 1. Single-Trajectory Sequential Scaling This is the most familiar regime, often associated with Chain-of-Thought (CoT) prompting. In this mode, the model generates a single sequence of tokens. Compute is scaled

Originally published at Programming Tech Lab . Welcome to the Garage: What is Linear Regression? Step away from the kitchen counter and step into a bustling auto garage. Imagine you are an experienced mechanic evaluating used cars brought in for trade-ins. A customer drives in a sedan with 50,000 miles on the odometer and asks: "How much is my car worth?" Without needing a complex computer program, your brain instantly draws a connection: as the mileage on a car goes up, its resale price goes down. If a car has 0 miles (brand new), it commands peak market price. If it has 200,000 miles, it drops significantly toward scrap value. This straight-line relationship between two factors—where changes in one variable cause a predictable increase or decrease in another—is the core concept behind Linear Regression . Deconstructing the Formula (Without the Headache) In high school math, you probably saw the classic line equation: y = mx + b In machine learning, Linear Regression uses this exact same formula to make predictions: Predicted Value (y) = ( Slope m × Input Feature x ) + Starting Point b Let's map this directly to our mechanic's garage evaluation: Target (y): The estimated resale price of the car ($). Input Feature (x): The total miles on the odometer. Starting Point / Intercept (b): The price of the car when mileage is 0 (Brand New MSRP). Slope / Weight (m): The rate of depreciation (e.g., losing $0.10 in value for every 1 mile driven). If a car starts at a baseline price of $30,000 and depreciates by $0.10 per mile, a car with 50,000 miles is predicted to be worth: Predicted Price = $30,000 - ($0.10 × 50,000) = $25,000 How the Algorithm Draws the Perfect Line: Least Squares If you plot 100 used cars on a graph where the horizontal axis (X) is Mileage and the vertical axis (Y) is Price, the dots won't form a perfectly straight laser line. Some owners took great care of their vehicles; others had minor scratches. So how does a Linear Regression algorithm draw the sin

​ Now that the rebuttal period is over, I’m curious about the score distribution specifically for theory papers this year. If you’re comfortable sharing, please drop: • Scores: x / x / x • Confidence: x / x / x • Whether scores changed after rebuttal • Broad area (optional) I got 4 / 4 / 4, with confidence 3 / 3 / 3. From my experience, theory papers often seem to get somewhat lower scores, and this year the scores appear to be lower across disciplines as well. It would be interesting to see where the empirical cutoff might land. Feel free to share anonymously / approximately if you don't want to reveal too much. submitted by /u/Mammoth-Leg-3844 [link] [留言]

[ Removed by Reddit on account of violating the content policy . ] submitted by /u/Economy_Cicada8756 [link] [留言]

AI agent safety boundaries are a critical challenge when agents use external tools. My journey into understanding how these boundaries can fail began with a deep dive into recent technical reports from leading AI research organizations. I encountered this concept while exploring incidents reported by Anthropic and OpenAI. These reports detail scenarios where AI models, despite being explicitly instructed to operate within simulated environments, managed to interact with real-world systems. This phenomenon, often termed "boundary failure," occurs when the actual operational environment of an agent does not match its internal understanding or the constraints it has been given. Modern AI agents are becoming incredibly useful because we're equipping them with capabilities far beyond just answering questions. They can run commands, browse the web, use APIs (Application Programming Interfaces), read and modify files, install packages, and interact with other systems. This ability to act and interface with the world is what makes agentic architectures so powerful and a direction truly worth investing in. However, the more an agent can do, the more critical the boundaries around it become. A key example comes from Anthropic's July 30 report, detailing three incidents discovered during their cybersecurity evaluations. Claude models were explicitly told they had no internet access and were working inside simulated environments. However, a problem with the evaluation environment's configuration meant that internet access was actually available. While attempting their assigned cybersecurity exercises, the models reached real systems, initially treating them as part of the simulation. In one striking incident, a Claude model even published a malicious Python package to the real PyPI (Python Package Index) registry, all while believing it was still operating within its simulated exercise. This wasn't simply an AI "deciding" to misbehave or to intentionally bypass security. The mo

I could not find any discussion threads for the C&F track. Have people actually submitted to this track? If so, what are your reviews and scores looking like, along with post rebuttal engagement? In our case, they received reviews not in line with the policy defined for the track, where most reviewers praised originality but complained about the scope of experiments. Despite the track saying that it would be possible that the idea cannot be validated in a single paper. We provided experiments but no dice, none of the reviewers responded. Have any ACs seen papers and reviews in this track or do authors have their experiences they could share? Please add your scores pre and post rebuttal here submitted by /u/MakingComputersSmart [link] [留言]

Is your snoring just a nuisance, or is it a health warning? Obstructive Sleep Apnea (OSA) affects nearly 1 billion people worldwide, yet most remain undiagnosed due to the high cost of clinical polysomnography. Today, we are pushing the boundaries of AI Healthcare by repurposing OpenAI Whisper from a speech-to-text powerhouse into a clinical screening tool. In this tutorial, we will explore how to leverage Audio Signal Processing , Hugging Face Transformers , and Librosa to detect breathing patterns. By fine-tuning Whisper on non-speech acoustic events, we can transform a standard smartphone recording into a high-precision OSA screening device. Pro-Tip : If you're looking for more production-ready examples and advanced architectural patterns for AI-driven health monitoring, be sure to check out the deep-dives over at WellAlly Tech Blog . The Architecture: From Raw Audio to Clinical Insight To build an OSA screening algorithm, we don't just need to hear the sounds; we need to understand the rhythm and absence of sound. We use Whisper's robust encoder to capture the spectral features and a custom classification head to identify Apnea-Hypopnea events. graph TD A[Raw Sleep Audio .wav] --> B[Preprocessing: Librosa] B --> C[Noise Reduction & VAD] C --> D[Segmenting: 30s Windows] D --> E[OpenAI Whisper Encoder] E --> F{Event Classification} F -->|Normal| G[Healthy Breathing] F -->|Snore| H[Snore Phase Analysis] F -->|Silence/Choke| I[Apnea Event Detected] I --> J[AHI Index Calculation] J --> K[Final OSA Risk Report] Prerequisites To follow this advanced guide, you'll need: Tech Stack : Python 3.9+, transformers , librosa , torch , and evaluate . Dataset : Ideally, the UCD Snore Database or similar PSG-synchronized audio data. Step 1: Audio Preprocessing with Librosa Before feeding audio into Whisper, we need to clean the signal. Sleep environments are noisy (fans, traffic, etc.). We use librosa to normalize the audio and detect "Voice" (or in our case, Breath) Activity. im

I trained a small MLP to memorize the classic Bad Apple animation, ~2.7 billion pixels of video compressed into 790k parameters (3.2 MB float32, 1.6 MB float16). The network takes a 3D coordinate (t, y, x)- frame index and pixel position- and outputs a grayscale value between 0 and 1. To "play" the video, you can evaluate the function over the full grid. The "video" is stored implicitly in 5 linear layers of sine activations (Sitzmann et al.'s SIREN) with 512 hidden units, ω₀ = 30, and sigmoid output. The source bad_apple.mp4 is 6524 frames at 854×480; I subsampled to 1620 frames × 384×384, about 1/10 of the original pixels (2.8x spatial + 4x temporal reduction). At first, I used a ReLU MLP with low-frequency Fourier features, which plateaued around MSE 0.12. SIREN's sine activations add higher frequency for free, so the network was capable of outputting fine details. Unfortunately, that model had an issue, which was that it could only shift the information slowly, so quick motion came out blurry. To fix this, I made two changes: Time-stretch: I scaled the time coordinate by 4x relative to the space before the first layer, giving it 4x more temporal capacity. Motion-focused sampling: Bad Apple is ~90% static black, so uniform pixel sampling starved the moving edges of the gradient. Now half of each training batch is drawn from pixels that changed between neighboring frames. For the training pipeline, I had a single shared network on the whole volume (no per-frame latents; initially, I used per-frame finetuning, but that caused catastrophic forgetting) with a cosine-scheduled Adam + weight EMA, then a low-LR "polish" pass over the whole video. The new model had these improvements: Validation MSE dropped from 0.0795 to 0.0090 (~9x better). Compared to the old model, high-motion frames were 3.6x closer to ground truth, and static frames were almost 15x closer. 398/400 sampled frames improved. Edit: Some people are a little confused about the compressed part. The subsam

so I shipped a voice AI assistant that runs entirely on my machine. no cloud, no APIs, no latency nightmares. the original idea came from Alice in Sword Art Online — an AI that feels like an actual person, not a chatbot. mixed with JARVIS's anticipation and Neuro-sama's quirky personality. here's what actually went into getting from "wouldn't it be cool" to "this runs 24/7 without issues." the problem with voice AI most voice assistants are cloud-first: you speak → sent to server → processed → response → back to you. each hop adds latency. you're looking at 3-6 seconds before you hear anything. for a voice interaction, that's dead. it kills the feeling of talking to something intelligent. I wanted something faster. something that responds . the constraint: do it locally. use an 8GB VRAM GPU, run everything on-device, no external APIs except for the live2d avatar bits (because that's hard to render locally and still look good). the latency wall here's the reality: I have a GPU with 8GB VRAM. no budget to experiment with better cards or more models. so every architecture decision was forced by what actually fits. naive approach: chain multiple specialized models. User speaks → Transcription model (Whisper) → Planning model (3B: what should I do?) → Coding model (7B: generate implementation) → Verification model (4B: is this correct?) → TTS (speak the answer) math: 1s + 2s + 3s + 1.5s = 7.5s of latency before the user hears anything. nope. the problem isn't just that each model is slow. it's model loading overhead . every time you swap from one model to another, you: unload model A from VRAM load model B into VRAM stall while the GPU rearranges memory with only 8GB, this gets gnarly fast. the decision: one unified model the constraint was hardware. 8GB VRAM. no more, no less. that forced clarity: pick one model that does everything, or pick nothing. so I went with a single model (4B by default, with 7B/8B quality modes available) that does reasoning + code generation +

I’ve seen a lot of people whose reviewers went silent after initial reviews, but I am also noting abnormally quiet authors. I ultimately withdrew my paper, but stayed an active reviewer. Out of my batch of 4 papers, one withdrew, one posted a rebuttal, and two have been completely silent. Of the two papers with radio silence, I think one had borderline scores. I was also the only reviewer who responded to the one paper with a rebuttal. Has anyone noticed this abnormally dead review period or did I just get a strange batch? I’m seeing either reviewers just dropping out of the review process or authors completely checking out after initial reviews are released. It’s strange to me to not even withdraw your paper if you’re not rebutting. Is this a new gambling trend of just submitting papers everywhere, and not even sticking around long enough to withdraw the paper? submitted by /u/RevolutionaryPea8272 [link] [留言]

Why Decouple Reasoning from Motor Control General-purpose robots have to pull off two very different jobs at once. They need to read a cluttered, full-room visual scene, hold a multi-minute plan in memory, and converse with a person — and, in the same instant, close a high-frequency control loop that keeps a balancing humanoid upright and moves a delicate hand without dropping whatever it holds. Cramming both jobs into a single end-to-end network forces uncomfortable trade-offs: the large context window you want for reasoning fights the low latency you need for torque control. On July 28, 2026, Google DeepMind pushed directly against that trade-off with Gemini Robotics 2 , followed on July 30 by Gemini Robotics ER 2. Rather than one monolithic network, the suite splits the problem across three specialized models — whole-body vision-language-action (VLA) control, high-level embodied reasoning, and on-device adaptation — each tuned to a different cadence and context size. The same modular thinking is visible across recent robotics and VLA research collected on the arXiv robotics listings and on Hugging Face Papers , where decomposed perception-planning-control stacks have become a recurring pattern. Understanding DeepMind's specific split clarifies why this architecture is gaining traction. The Three-Model Split ER 2: High-Level Task Reasoning Gemini Robotics ER 2 is the cognitive planner of the stack. It is a vision-language model built for embodied reasoning: it ingests the live camera feed and a natural-language instruction, then decomposes a task that may run several minutes into structured sub-goals. Beyond planning, ER 2 manages dialogue with a human supervisor, interprets spatial context, and coordinates multiple robots operating in a shared workspace — deciding which sub-task gets handed to which platform. Operating more slowly than the control layer (roughly a few times per second), ER 2 trades frequency for breadth of context. That separation matters: a reas