标签：#learn

2.6.1. Object Safety When defining a trait, whether it is object-safe is also part of the unstated contract. Object safety is a concept in Rust related to trait objects . It determines whether a trait can be dynamically dispatched, that is, whether it can be used in the form of dyn Trait . Traits That Are Object-Safe Must Satisfy the Following Conditions (Based on RFC 255) All supertraits must also be object-safe If a trait inherits from other traits, then those supertraits must also be object-safe. It must not require Sized A trait cannot use Sized as a supertrait, meaning it cannot contain a Self: Sized bound, because the size of a trait object is unknown at compile time. It cannot have associated constants . It cannot have associated types with type parameters . All associated functions (methods) must satisfy one of the following rules : Dispatchable functions : They cannot have any type parameters, though lifetime parameters are allowed. They must be methods, and Self may only appear in receiver positions such as: &self &mut self Box<Self> Rc<Self> Arc<Self> Pin<P> (where P is one of the types above) They cannot require Self: Sized , otherwise the trait would only be usable for types with known size and object safety would be broken. Explicitly non-dispatchable functions : They may return Self , but such functions must require Self: Sized , so they cannot be called on trait objects and can only be used with concrete types. If you cannot remember all of the above, just remember object safety describes whether a trait can be safely turned into a trait object . What Object Safety Does If a trait is object-safe, meaning it satisfies all of the conditions above, then we can use dyn Trait to treat different types that implement the trait as a single generic type. If it is not object-safe, the compiler will prevent you from using dyn Trait . Object Safety and API Design When designing APIs, it is recommended to make traits object-safe, even if that slightly reduces con

OpenAI quietly rolled out improvements to GPT-5.6 Sol in ChatGPT this week, and the AI community took notice. The update, which hit the front page of Hacker News with over 70 points, brings measurable quality improvements and — crucially — expands access to free users. What Changed in GPT-5.6 Sol? The update focuses on three areas: 1. Improved Reasoning on Complex Tasks GPT-5.6 Sol shows improved performance on multi-step reasoning tasks. This includes better handling of: Mathematical proofs and calculations Code debugging across multiple files Logical deduction chains Multi-constraint optimization problems The improvement appears to come from refined training data curation and reinforcement learning from human feedback (RLHF) targeting reasoning-heavy tasks. 2. Better Instruction Following The model now follows complex, multi-part instructions more reliably. Where GPT-5.6 Sol previously might miss one constraint in a list of five, the updated version handles compound instructions more consistently. For developers building prompt-based applications, this means: Fewer retry loops Better structured output generation More reliable tool calling 3. Expanded Free User Access Perhaps the most significant change for the broader AI community: OpenAI expanded free user access to GPT-5.6 Sol. Previously available only to Plus subscribers, the model is now accessible to a wider audience. This has implications: For developers : Larger potential user base for GPT-5.6-powered apps For competitors : Pressure on pricing — if the best models are free, paid tiers need clear differentiation For open source : The gap between free proprietary models and open-source alternatives narrows the value proposition of self-hosting How Does It Compare? The Artificial Analysis Agentic Index — an independent benchmark — currently ranks GPT-5.6 Sol among the top models, though Qwen3.8 Max has recently taken the #1 spot on agentic tasks. The competitive landscape as of August 2026: Model Intelligence

The AI leaderboard just had a seismic shift. Qwen3.8 Max, Alibaba's latest open-weight model, has been ranked as the best overall model by the Artificial Analysis Agentic Index — beating out GPT-5.6 Sol from OpenAI, Claude Opus 4.5 from Anthropic, and Gemini Ultra 2 from Google. This isn't just a benchmark win. It's the first time an open-source model has topped a comprehensive agentic intelligence index that measures real-world task performance, not just test scores. What Is the Agentic Index? The Artificial Analysis Agentic Index is an independent benchmark that evaluates AI models on their ability to complete agentic tasks — multi-step reasoning, tool use, code generation, and real-world problem solving. Unlike traditional benchmarks (MMLU, HumanEval) that test static knowledge, the agentic index measures whether a model can actually do things . The index evaluates models across multiple dimensions: Intelligence Index : Composite score across reasoning, coding, math, and instruction following Speed : Output tokens per second under production load Cost : Weighted average cost per intelligence task Endpoint Accuracy : Whether provider endpoints match reference model quality Qwen3.8 Max: The Specs Qwen3.8 Max represents Alibaba's most capable model to date: Parameters : 240B (MoE architecture, ~35B active during inference) Context : 256K tokens native, 1M extended Training : Trained through November 2025 data cutoff Licensing : Open weights for research and commercial use (with restrictions for users in restricted jurisdictions) What makes Qwen3.8 Max notable isn't just raw intelligence — it's the combination of high performance with competitive pricing and speed. The model scores near the top on intelligence while maintaining cost per task well below premium alternatives. Why This Matters for Developers 1. Open-Source is Catching Up — and Pulling Ahead For two years, the gap between open-source models (Llama, Qwen, Mistral) and proprietary frontier models (GPT, Cla

There's no shortage of advice on landing your first software engineering role. Portfolios, interviews, which languages to learn. What I found far less of, when I was starting out, was anything on what to do once you're actually in the building. So when The Tech Academy asked me to give a talk at the end of July, mostly to students and people lining up their first role, that's what I talked about. You're joining a system somebody else built, that's live, and that you now have to keep running. None of what follows comes up while you're learning to code. It only shows up once you're standing in front of the real thing. Give the last engineer the benefit of the doubt You will join somewhere and find things that look wrong. You've just spent months learning how it's meant to be done, and the real thing won't match. When that happens it's tempting to say so, loudly, and to wonder aloud what the last person was thinking. Try not to. Every system I've worked on was built by people making the best call they could with the information, the tools and the deadline they had at the time. I've not yet found a bad decision that was made carelessly, and I've made plenty of my own that looked fine on the day and worse a year later. There's a practical edge to it as well. The business doesn't watch individual engineers make individual decisions, it sees engineering as one thing, so when you run down the engineer before you, the credibility you spend is partly your own. The attitude that serves you better is that you're going to inherit systems you didn't build, and owning their flaws is the job. Small failures beat big ones The clearest foundational mistake I've seen up close was a process that had to succeed all at once. It did a large piece of work in a single pass, and any failure anywhere failed the whole thing. At small volumes nobody notices. As the numbers grow the odds of falling over climb with them, and a system that half-finished its work leaves a worse mess than one that d

Whether generating CELEBV-HQ videos or turbulent plasma fields (digital twins), autoregressive models (such as latent diffusion or flow models) accumulate error over long rollouts, yet at deployment there is no ground truth to measure against. I train a single conditional latent diffusion model that steps a dynamical system forward or backward in time via a direction flag, and show that this bidirectionality supplies a measurement-free test-time error signal: rolling forward steps and then backward steps must return the model to its start, so the round-trip discrepancy is a self-supervised proxy for the unobservable rollout error: no ensembles, no held-out data, no governing equations, for one extra rollout. Furthermore, training both directions in one network is shown to beat two specialist models in both directions. Paper: https://arxiv.org/abs/2608.00675 Code (data generation, training, analysis): https://github.com/alexscheinker/round-trip-consistency Project page: https://alexscheinker.github.io/roundtrip.html submitted by /u/Clean-Hovercraft5825 [link] [留言]

Cuando el objetivo es algo tan delicado como un diagnóstico asistido, confiar en un único modelo es arriesgado. FeliniAI usa tres pipelines complementarios que se refuerzan entre sí, igual que un veterinario combina lo que ve, lo que mide y lo que sabe. Pipeline 1 — Visión: MobileNetV2 Una CNN MobileNetV2 (PyTorch, transfer learning) clasifica imágenes de la piel/pelaje del gato en categorías visuales. Elegí MobileNetV2 por su equilibrio entre precisión y ligereza: corre rápido en CPU, lo que mantiene la inferencia por debajo de 1 segundo. Alcanza un 93,4% de accuracy visual . Pipeline 2 — Clínico: XGBoost + ICADA El núcleo del sistema es un clasificador XGBoost que trabaja sobre 33 features clínicas derivadas de los criterios ICADA (los criterios estandarizados de dermatitis atópica felina): estacionalidad, distribución de las lesiones, prurito, respuesta a tratamientos previos. Sobre un dataset de 8.000 casos , este módulo logra un F1 macro de 0.9675 en validación cruzada 5-fold. La búsqueda de hiperparámetros se hizo con Optuna y la explicabilidad con SHAP. Pipeline 3 — LLM: la síntesis Finalmente, un LLM ( Llama 3.3 70B vía Groq ) integra las salidas de los dos modelos anteriores y las traduce en una recomendación legible: qué tipo de alergia es más probable, con qué confianza y qué pasos sugerir. El LLM no diagnostica solo: orquesta y comunica lo que han calculado los modelos especializados. Por qué tres pipelines y no uno Porque cada uno cubre el punto ciego del otro. La visión capta lo que una foto muestra pero un cuestionario no; el modelo clínico capta el historial que una foto no puede mostrar; el LLM convierte ambos en algo accionable. Es un patrón de ensemble heterogéneo aplicado a datos de naturaleza distinta. Resultados F1 macro (clínico): 0.9675 , accuracy 0.9909. Accuracy visual: 93,4%. 4 tipos de alergia, 33 features clínicas, <1s de inferencia. Qué aprendí Que en dominios sensibles, la arquitectura correcta no es "el modelo más grande", sino varios

2.5.1. Code Contracts Your code, whether explicitly or implicitly, contains a contract. A contract has two sides: A contract is a requirement, which is a restriction on how the code is used A contract is a promise, which is a guarantee about how the code behaves When designing APIs, there is a useful rule of thumb: avoid imposing unnecessary restrictions, and only make promises you can keep . Why? Adding restrictions or removing promises requires a major semantic version change and may break other code When you first design an API, loosening restrictions and later adding extra promises is usually backward-compatible 2.5.2. Restrictions and Promises Common forms of restrictions in Rust are: Trait bounds Argument types Common forms of promises are: Trait implementations Return types Some Examples Let's look at an API evolving through three versions: fn frobnicate ( s : String ) -> String The first version takes a String and returns a String Its contract is that the caller performs allocation (because both the parameter and return value are owned, allocation is inevitable), and its promise is that it returns an owned String The problem with this function is that, without changing the signature, it cannot later be turned into a “no-allocation” function, because both the argument and return value are owned fn frobnicate ( s : & str ) -> Cow < '_ , str > The second version relaxes the contract a bit Its contract is that it accepts only a string reference, and its promise is that it returns either a string reference or an owned String , namely the Cow type This version is still somewhat rigid. For example, the argument is &str ; if I pass in a String , I still have to convert it first. Also, because the return value is Cow , it cannot return string-owning types other than String and &str (for example, OsString ) fn frobnicate < T : AsRef < str >> ( s : T ) -> T The third version relaxes the contract further Now both the parameter and the return value only require a type th

Originally published in Spanish on El Rack. Browser translation handles the rest of the site fine if you're into homelab/self-hosting content. Moonshot AI released Kimi K3 on July 17, 2026, and made the weights publicly downloadable on July 27. At 2.8 trillion parameters, it's the largest open-weight model ever published — and according to multiple benchmarks, it rivals Claude Opus and GPT on coding, reasoning, and general knowledge work, at a fraction of the training cost. The New York Times ran an in-depth piece on it a few days after release, which tells you this isn't just another model drop. What "open weights" actually gets you here Publicly downloadable weights mean any company or researcher can run this locally and modify it without depending on a third-party API. If you already run Ollama or LM Studio in your homelab, that's the tempting part: a frontier-level model, no monthly quota, running on your own hardware. The practical reality is different. "2.8 trillion parameters isn't a number that runs on homelab hardware — it needs an enterprise-grade GPU cluster. The weight release is real, but "downloadable" and "runnable" are very different things at this scale." The bigger debate this reopened What makes Kimi K3 interesting isn't just the benchmark numbers — it's what it represents in the ongoing dispute over AI's geopolitics. The same fracture that opened up around DeepSeek-R1 in January 2025 is back: some argue US labs need to close up more in response to Chinese competition, others see openness as the only real way to stay relevant against an ecosystem that ships open weights at a pace closed labs can't match on transparency. There's also a real technical concern underneath: the possibility that outside actors use massive querying of closed American models to distill their outputs and train competing open models. Where this actually matters for a homelab Even though K3 itself is unrunnable on consumer hardware, its release pushes down what smaller, actu

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] [留言]