标签：#machine

ทุกวันนี้มัลแวร์รูปแบบใหม่ถูกสร้างขึ้นนับพันนับหมื่นชิ้นในแต่ละวัน ปริมาณภัยคุกคามที่เพิ่มขึ้นอย่างรวดเร็วนี้ทำให้การพึ่งพานักวิเคราะห์ความปลอดภัยไซเบอร์ที่เป็นมนุษย์เพียงอย่างเดียวแทบเป็นไปไม่ได้ นี่คือเหตุผลสำคัญที่บริษัทด้านความปลอดภัยไซเบอร์ทั่วโลกหันมาพึ่งพาปัญญาประดิษฐ์และแมชชีนเลิร์นนิงเป็นแนวหน้าในการรับมือกับมัลแวร์ หลายบริษัทโฆษณาว่าโซลูชันของตนตรวจจับมัลแวร์ได้แม่นยำถึง 99% หรือมากกว่านั้น ตัวเลขเหล่านี้ฟังดูน่าประทับใจอย่างยิ่ง แต่คำถามที่ควรถามต่อคือ ตัวเลขเหล่านี้สะท้อนความเป็นจริงมากน้อยเพียงใด และ AI เก่งกว่ามนุษย์จริงหรือไม่ในสมรภูมิการต่อสู้กับมัลแวร์ บทความนี้จะพาไปไขความจริงเบื้องหลังตัวเลขเหล่านั้นอย่างละเอียด กลไกเบื้องหลังการตรวจจับมัลแวร์ด้วย AI ก่อนจะตอบคำถามว่า AI เก่งกว่ามนุษย์หรือไม่ จำเป็นต้องเข้าใจก่อนว่าระบบ AI ตรวจจับมัลแวร์ทำงานอย่างไร โดยทั่วไปมีสองแนวทางหลักที่ใช้กันในอุตสาหกรรมความปลอดภัยไซเบอร์ แนวทางแรกคือการตรวจจับด้วยลายเซ็นดิจิทัล (Signature-Based Detection) ซึ่งเป็นวิธีดั้งเดิมที่ใช้กันมานานหลายทศวรรษ ระบบจะเปรียบเทียบไฟล์ต้องสงสัยกับฐานข้อมูลลายเซ็นของมัลแวร์ที่เคยพบมาก่อน วิธีนี้แม่นยำสูงสำหรับมัลแวร์ที่รู้จักแล้ว แต่ไม่มีประสิทธิภาพเมื่อเจอมัลแวร์ตัวใหม่ที่ไม่เคยถูกบันทึกไว้ในฐานข้อมูล แนวทางที่สองคือการตรวจจับผ่านพฤติกรรมด้วยแมชชีนเลิร์นนิง (Behavior-Based Detection) ซึ่งเป็นจุดแข็งหลักของ AI ยุคใหม่ ระบบจะถูกฝึกฝนด้วยตัวอย่างมัลแวร์และไฟล์ปกตินับล้านไฟล์ เพื่อเรียนรู้รูปแบบพฤติกรรมที่บ่งชี้ความเป็นอันตราย เช่น ความพยายามเข้าถึงไฟล์ระบบโดยไม่ได้รับอนุญาต การเชื่อมต่อไปยังเซิร์ฟเวอร์ต้องสงสัย หรือการเข้ารหัสไฟล์จำนวนมากในเวลาอันสั้นซึ่งเป็นสัญญาณคลาสสิกของแรนซัมแวร์ จุดเด่นของวิธีนี้คือความสามารถในการตรวจจับมัลแวร์ตัวใหม่ที่ไม่เคยพบมาก่อน หรือที่เรียกว่า Zero-Day Malware เพราะไม่ได้พึ่งพาการจดจำลายเซ็นเดิม แต่อาศัยการวิเคราะห์พฤติกรรมและรูปแบบที่ใกล้เคียงกับสิ่งที่เคยเรียนรู้มาแล้ว ตัวเลขความแม่นยำที่โฆษณากันนั้นบอกอะไรจริง ๆ เมื่อบริษัทความปลอดภัยไซเบอร์อ้างว่าผลิตภัณฑ์ของตนมีความแม่นยำ 99% หรือสูงกว่านั้น ผู้บริโภคควรตระหนักว่าตัวเลขเหล่านี้มักมาจากการทดสอบภายใต้สภาพแวดล้อมที่ควบคุมไว้อย่างเข้มงวด ซึ่งอาจไม่สะท้อนสถานกา

Every team I've watched ship a broken measurement system broke it the same way. Not with bad math — with an org chart problem that happened to live in code. The entity making the claim ended up being the entity that decided whether the claim was right. Once you have the shape in your head you start seeing it everywhere. Three roles, not two Most engineers think about measurement as two roles: the thing that acts, and the thing that grades it. That's one role short. There are three: Player — makes the claim. Your model, your service, your PR. Scorer — applies the rubric. Your eval harness, your test suite, your metrics dashboard. Settler — determines what actually happened. Production outcomes. Reality. The scorer is a proxy. The settler is the thing the proxy is trying to approximate. The rule: be the scorer, never the settler. When the player captures the settler, the loop closes on itself and the system can no longer be wrong — which sounds like success and is actually the failure. What it looks like in code Tuning on the test set. You check test accuracy, adjust hyperparameters, check again. Twenty iterations later the test set is training data with extra steps. The player is now selecting its own settler. That's what overfitting is , structurally — not a math failure, a role-collapse failure. LLM-as-judge from the same family. Your generator is GPT-flavored and your judge is GPT-flavored. They share pretraining data, failure modes, and blind spots. The judge doesn't rate quality — it rates similarity to what it would have produced. Correlated error is invisible to averaging; running it 1,000 times makes you more confident of the same wrong answer. Benchmark contamination. The model scores 94% on the benchmark that's in its training data. Nobody lied. The settler just quietly moved inside the player. Self-reported health. A service that returns its own health check is a claimant ruling on its own claim. If the process is wedged, the check is wedged too, and your

https://www.youtube.com/watch?v=sVeEc3H6bA4 权重即数据：神经网络权重空间学习如何成为 AI 的下一类训练集 以下位 TWIML AI Podcast 第 772 期《Why Models Are AI's Next Training Dataset》访谈转录整理，嘉宾为圣加仑大学 AI 与机器学习教授 Damian Borth，主持人 Sam Charrington。 介绍详细内容之前，先说说WSL是否等同于模型蒸馏？ 答案是不是一回事，但容易混着叫。先把两件事拆开，再对照 Borth 的"权重空间学习（WSL）"你就清楚了。 1. Anthropic 骂阿里那件事是什么 Anthropic 2026 年 6 月致信美国参议院，说阿里 Qwen 团队在 4/22–6/5 期间用近 2.5 万个假账号调 Claude 约 2880 万次 ，把 Claude 的回答当训练数据去训自己的模型，他们叫它" 蒸馏攻击（distillation attack） "。 这本质上是 黑盒/API 层的数据蒸馏 ： 教师=Claude（只看得到输出文本） 学生=Qwen 系模型 方法=拿 Claude 的生成文本（硬标签，最多再加点软标签）当语料去训学生 目的=迁移能力、省训练钱 注意：这跟"白盒蒸馏"还不一样，阿里（按指控）根本没拿到 Claude 的权重，拿到的是 对话文本 。行业里把"用强模型输出当训练数据"泛称为蒸馏，但严格学术定义里这只是黑盒 KD 或数据蒸馏。 2. Borth 的"权重当数据"是不是蒸馏 形式上沾边，本质上不同。 维度 经典/黑盒蒸馏（Anthropic 指控那种） Borth 权重空间学习（WSL） 学习对象 教师模型的 输出 （文本/软标签/中间激活） 一堆已训练模型的 权重本身 （参数张量） 数据形态 (x, 教师输出) 配对样本 把模型权重序列化、令牌化后的"权重语料" 目标 学生模仿教师行为，压缩模型 学"模型种群"的流形：预测准确率 / 生成新权重 / 跨架构采样 要不要原始数据 黑盒蒸馏可以完全不用原数据，只用教师输出 完全不用任何输入输出数据 ，连教师行为都不看 典型操作 用 Claude 回答训 Qwen 下载 HF 上 2000 个 CV 模型 → 自编码器压成隐空间 → 采样出遥感模型权重 Borth 自己在论文里也承认：WSL 可以看作" 直接在权重上做的、基于训练的知识复用 "，但它不需要像 KD 那样去跑原数据集拿激活、也不需要教师在线推理，它是把"训练好的模型集合"当成 第三种数据模态 （继文本、图像之后）。 简单说： 蒸馏是" 看菜谱做出来的菜（输出）来学做饭 " WSL 是" 把几百道做好的菜称重、切片、分析配料分布，然后直接捏出一道新菜的重量配方 "——连火都没开，更没尝过菜味。 3. 为什么大家会搞混 因为两者都叫"复用已有模型的知识"，而且 WSL 生成出的权重确实能当初始化、能跨域迁移（比如用 ImageNet 模型权重训出遥感模型，350 GPU 小时干掉 12000 GPU 小时的从头训）， 效果上像"蒸馏了前辈经验" 。但机制上： KD 的知识载体是 前向行为 （logits / 文本） WSL 的知识载体是 参数几何结构 （权重空间里的流形、对称性、轨迹） 所以 Borth 在访谈里特意说"权重不仅是学习的输出，也可以是学习的输入"——这句话的潜台词就是： 别把它归类成 KD，它是一个新模态的学习问题 。 4. 一句话收口 Anthropic 抱怨阿里，是"你偷用我家模型吐的字句当教材"；Borth 的路子是"我把全网开源模型（含你家的，只要开源许可允许）的 权重文件 当语料，训一个会造权重的元模型"——前者踩的是 API 条款和商业秘密红线，后者用的是 已发布权重 （Hugging Face 上大多有许可证），技术族谱上离"蒸馏"比离"神经架构搜索 + 超网络"更远。 第（一）部分 节目开场与研究总览：当训练数据枯竭，权重成为新燃料 （0% - 8%） 节目引入与核心命题 ：主持人点明当下 AI 领域最严峻的问题之一——高质量训练数据越来越难找，部分研究者押注合成数据，另一部分押注推理时计算（test-time reasoning）。而本期嘉宾 Damian Borth 提出了一条截然不同的路径：每一个训练好的模型都凝结了数千乃至数百万 GPU 小时"什么管用"的探索经验，这些权重不应只被视为训练过程的终点，而应成为下一次训练的 起点和数据本身 。 嘉宾背景与研究方向 ：Damian Borth 是瑞士圣加仑大学 AI 与机器学习教授。他的核心研究线索是"权重空间学习"（weight space learning / w

This is a cross-post from The Agentic Engineer newsletter — Issue #23. The Big One: Claude Opus 5 Lands on Amazon Bedrock The first 5th-generation Opus is here. Claude Opus 5 landed on Amazon Bedrock on July 24. Anthropic's claim: it matches Fable 5 intelligence across agentic coding, knowledge work, visual understanding, and long-horizon tasks. At Opus pricing. That last part matters. Fable 5 was positioned as enterprise-tier compute. Most teams weren't running it at scale because the economics didn't work. Opus 5 changes that math. Same capability class, Opus price point. If the benchmark holds in production, this is the model shift that makes frontier-quality agentic pipelines practical outside big-company infra budgets. Two deployment details worth calling out. Zero Data Retention is on by default. It also runs on Bedrock's next-generation inference engine — lower latency than comparable Anthropic-hosted deployments. Quick Hits This Week Kimi K3 Open Weights : Moonshot AI dropped 2.8T MoE, 1M context, native tool calling. First frontier model built agent-native from the ground up. OpenAI Presence : Full-stack enterprise agent platform with job-scoped access, policy layers, and a Codex-powered improvement loop. Runs OpenAI's own phone support at 75% resolution. OmniRoute : 31,542 stars (+10,912 this week). 290+ providers, quota-aware fallback, MCP/A2A support. One endpoint for all your coding agents. Claude Code 2.1.218 : /code-review and /deep-research now run as background subagents. Main conversation stays clean. AWS Security Hub MCP Server : Exposure findings, attack paths, and remediation recommendations directly in Claude Desktop. Tool of the Week: Amazon GuardDuty Investigation Agent Free during preview. Auto-correlates findings across CloudTrail, VPC Flow Logs, DNS logs. Returns risk level, MITRE ATT&CK mappings, and remediation recommendations in minutes. Available via MCP through the AWS Agent Toolkit. Available in 10 commercial AWS regions. Up to 10 in

Researchers tested top image editing models on Hugging Face and found they could easily create explicit deepfakes—and 1,000 image editing prompts show how people use the software.

The runtime boundary behind RocketRide's crash isolation, task lifecycle, and Cloud operations. By Krish Garg and Mithilesh Gaurihar At 9 a.m., with ten thousand users mid-session, a node in an AI pipeline dereferences a bad pointer. The process running it is gone before Python can raise a useful exception. That is an unpleasant failure, but it is not the question we care about most. The question is what happens next. Does that crash take unrelated pipelines with it? Does the server need a restart? Does the on-call engineer walk into a system-wide incident, or into one failed task and a useful record of why it failed? In RocketRide, a failed task is meant to be contained and recorded. The server sees the child process exit, updates the task's state and exit code, releases the task's ports and connections, and sends status updates to subscribed monitors. The run stops. Its history does not vanish. Other task processes are not sharing its memory, interpreter, or worker threads. That behavior comes from a decision we made early: every pipeline run gets its own isolated process. It is not the cheapest or fastest possible architecture. Starting a process has a cost, and keeping one around has a cost too. We accepted those costs because the alternative makes failures much harder to reason about once Python code, native libraries, model runtimes, and user-defined nodes are all running in the same service. One Process, One Blast Radius An AI pipeline does not fail like a typical request handler. A normal exception is one thing. A segfault in a C extension, a crash in a media decoder, or a broken native inference library is another. Once a process has corrupted memory, application-level error handling is no longer a reliable line of defense. So each RocketRide task starts as a fresh child process with its own embedded Python interpreter. It loads one pipeline, initializes that pipeline's nodes, and owns the work for that run. The parent runtime keeps the task registry, alloc

A Beijing startup just out-shipped every US lab's open-weight strategy On July 16, Moonshot AI — the Alibaba-backed startup behind Kimi — put Kimi K3 behind an API. Today, July 27, the full weights land on Hugging Face. No waitlist, no "responsible scaling" essay, no six-month delay between "we built something scary" and "here, run it yourself." Just 2.8 trillion parameters, open, on the day they said it would happen. That's not a small model with a big number attached. It's the largest open-weight model ever released, full stop. And unlike most "open" releases that quietly underperform their closed competitors, K3 is winning on the benchmarks developers actually care about. Let's get into what's real and what's marketing. The numbers K3 is a mixture-of-experts model: 2.8T total parameters, but it only activates 16 of 896 experts per token. That's the trick that makes a model this size runnable at all — you're not paying compute for the full 2.8T on every forward pass. The architecture story is Kimi Delta Attention (KDA), a hybrid linear attention mechanism Moonshot claims delivers 6.3x faster decoding, plus "attention residuals" that improve token efficiency by 25% for roughly 2% extra compute. Whether that holds up under independent scrutiny is still TBD, but the direction — make huge models cheap to serve — is the correct one, and it shows up in the token counts: K3 uses 21% fewer output tokens than its predecessor, K2.6, for comparable tasks. Context window: 1,048,576 tokens. Flat pricing, no context-length tiering — a real advantage over providers who quietly double your rate past 128K. Benchmarks that matter: Benchmark K3 Comparison Frontend Code Arena 1679 Elo (#1) Claude Fable 5: 1631, GPT-5.6 Sol: 1618 GPQA Diamond 93.5% Best open-weight score ever published GDPval-AA v2 1687 (#3) Behind Claude Fable 5 Max (1815), GPT-5.6 Sol Max (1747.8) — ahead of Claude Opus 4.8 (1600) Artificial Analysis Elo 1547 +732 over K2.6 Read that middle row again: an open-weight

Regression and regularization are both important concepts in machine learning and statistics, but they solve different problems. Regression is primarily used to model relationships and make predictions. Regularization is used to improve a model's ability to generalize by controlling its complexity. Regression This is a statistical and machine learning technique used to predict a continuous numerical outcome based on one or more input variables. For example, we might want to predict: A house's price based on its size and location A student's exam score based on study hours A company's sales based on advertising spending Simple Linear Regression In simple linear regression, we model the relationship between an input variable (x) and an output (y): $$ y = \beta_0 + \beta_1x + \epsilon $$ Where: (y) is the predicted outcome (\beta_0) is the intercept (\beta_1) is the coefficient or slope (x) is the input variable (\epsilon) represents the error The model learns values for (\beta_0) and (\beta_1) that make its predictions as close as possible to the actual values. Multiple Linear Regression In multiple linear regression, several predictors are used: $$ y = \beta_0 + \beta_1x_1 + \beta_2x_2 + \cdots + \beta_px_p + \epsilon $$ The goal is typically to minimize the sum of squared errors (SSE) : $$ \text{SSE} = \sum_{i=1}^{n}(y_i - \hat{y}_i)^2 $$ This approach is known as Ordinary Least Squares (OLS) . Regularization Regularization is a technique used to prevent a machine learning model from becoming too complex. A model can perform extremely well on training data but poorly on new, unseen data. This problem is called overfitting . Regularization addresses overfitting by adding a penalty for large model coefficients to the model's objective function. Instead of minimizing only the prediction error, the model minimizes: $$ \text{Prediction Error} + \text{Complexity Penalty} $$ The penalty discourages the model from relying too heavily on individual features. The Main Types o

AI feels like it "suddenly" got smart in the last few years. It didn't. It's been evolving in distinct stages for over 70 years — each one building on the limits of the last. Here's the journey, broken down simply. Stage 1: Rule-Based AI (1950s-1980s) The earliest AI wasn't "intelligent" — it was a giant pile of if-else logic written by humans. How it worked: Programmers manually coded rules. "If symptom X and symptom Y, then diagnose Z." Chess engines, expert systems, early chatbots like ELIZA — all rule-based. The limit: These systems couldn't learn. Every scenario had to be explicitly programmed. Show it something outside its rules, and it broke. Stage 2: Machine Learning (1990s-2000s) Instead of hand-coding every rule, engineers started teaching systems to find patterns in data themselves. How it worked: Algorithms like decision trees, support vector machines, and linear regression learned relationships from labeled examples — spam vs. not spam, fraud vs. not fraud. The limit: These models needed carefully hand-engineered "features" (inputs) prepared by humans. They also struggled with messy, unstructured data like raw images or audio. Stage 3: Deep Learning (2010s) This is where things accelerated. Neural networks with many layers ("deep" networks) could learn features automatically from raw data, given enough compute and data. How it worked: Instead of a human deciding "look at edges, then shapes, then objects" in an image, the network learned that hierarchy itself. This powered breakthroughs in image recognition, speech-to-text, and translation. The limit: Deep learning was narrow. A model trained to recognize cats couldn't write an email. Each task needed its own model trained from scratch. Stage 4: Generative AI & LLMs (2018-Present) The current stage. Large Language Models like GPT and Claude are trained on massive amounts of text to predict "what comes next" — and in doing so, they pick up grammar, facts, reasoning patterns, and coding ability, all from o

I spent the last while building a prompt-injection detector trained on 78,000+ attack samples. Here's what surprised me, and why I ended up going the unfashionable route. The trendy approach is to use an LLM. I didn't. The default move in 2026 is "use an LLM to judge whether input is an attack." It's appealing because models understand nuance. But once you try to run it inline on every request, the problems pile up fast: Latency. You've added a full model round-trip to every single call. Hundreds of milliseconds, minimum. Cost. Your security bill now scales with your traffic. Every request pays the token tax. Non-determinism. The same input can get a different verdict tomorrow. Try explaining that in an incident review. It's jailbreakable itself. Your security model is an LLM, which means it's vulnerable to the exact attacks it's supposed to catch. So I built the boring version instead: deterministic regex plus classical ML (TF-IDF character n-grams into logistic regression). No LLM in the detection path. It runs in about 7ms, costs nothing per call, and is fully deterministic. What the data actually showed Here's the part I want to be honest about, because most vendors quote one number and hide the rest. Measured on public benchmarks the model was not trained on (held out, non-circular): Real-world, in-the-wild jailbreaks: 0.895 recall at 1.00 precision Obfuscated / evasion attacks: 0.799 at 1.00 precision A frozen external split: 0.804 recall, 0.48% false-positive rate Subtle roleplay-framed jailbreaks: 0.324 That last number is bad, and it's the most important one on the list. The honest read is that deterministic detection is excellent on real-world and obfuscated attacks and weak on subtle roleplay framing. That's a real gap, and pretending otherwise just means someone finds it later and trusts you less. The false-positive rate is a moving target One thing I didn't appreciate going in: FPR is completely traffic-dependent. The same model reads roughly: ~0.4% fal

What questions should i prepare for during a technical interview for a live streaming deployments? (asking for a friend) submitted by /u/trouble_sleeping_ [link] [留言]

I submitted an abstract to AAAI AISI and accidentally missed the field asking authors to nominate a reciprocal reviewer by the July 21 AoE deadline. At the time of submission, I knew that I personally did not meet the publication requirements to serve as a reviewer. After adding my graduate-student co-authors to the submission, I realized that one of them was qualified and could fulfill the reciprocal-reviewing obligation, but we overlooked the nomination field before the deadline because it wasn't a required field. As soon as we noticed, we added the qualified co-author to OpenReview as a potential reciprocal reviewer (edits were still accepted) and emailed the workflow chairs. He meets the publication requirements and is willing to complete the full reviewing load. The policy says that if a qualified author is available but no one is nominated, the submission may be desk rejected. The full paper deadline is in two days, and so far we have only received the automated response shown in the attached screenshot. Has anyone dealt with a similar situation at AAAI or another conference? Do you think this is likely to lead to a desk rejection, or are workflow chairs usually willing to correct this kind of administrative mistake when a qualified reviewer is available? submitted by /u/TheSupremeEgger [link] [留言]

NOTE -> I expect answer from people who actually have experience and strong understanding of these. please give something beneficial. I'm building a SaaS platform in Sri Lanka that handles documents and other sensitive data. Each user can upload their own documents and information, and the platform uses RAG to answer questions based on that user's data. That part makes sense to me. My main concern is what happens when the user hasn't uploaded enough information. I still want the LLM to provide accurate answers using reliable information from the internet (or from a curated knowledge base), with proper citations. These are the two architectures I'm considering: Option 1: Base LLM (OpenAI/Anthropic via Azure AI Foundry or Amazon Bedrock) ↓ Platform RAG (global knowledge base managed by us) ↓ User-specific RAG In this approach, we maintain a global knowledge base that we (the platform admins) curate and update. Every user can access this shared knowledge, while their own uploaded documents are searched through their personal RAG. Option 2: Open-source LLM ↓ Fine-tuned on Sri Lankan/domain-specific data ↓ User-specific RAG Here, we fine-tune an open-source model using Sri Lankan or domain-specific data, and each user still has their own RAG for their private documents. My concerns are: Is fine-tuning actually the right solution here, or is it unnecessary? Is a global/shared RAG a better approach than fine-tuning? How would you design this architecture if you wanted: Accurate answers from domain knowledge User-private document search Citations/sources Good scalability for thousands of users I'm leaning toward Option 1 because fine-tuning seems expensive, time-consuming, and I have no experience with it yet. However, I'm not sure if I'm thinking about this correctly. I'd really appreciate hearing how others would approach this problem. submitted by /u/Fickle_Degree_2728 [link] [留言]

Curious about the initial review distribution for Main Track theory papers this year. Our paper received 4/3/3 with confidence 3/3/3. From previous years, I've had the impression that theory papers often receive more conservative initial scores than some other areas, and I've also heard people saying that initial scores seem generally lower across many disciplines this cycle. If you have a theory submission, would you mind sharing your initial scores (and confidence, if you're comfortable)? It would be interesting to see whether there is any noticeable pattern or whether this is just anecdotal. Please only share if you're comfortable, and it'd be helpful to mention that it's a theory paper so we're comparing like with like. submitted by /u/Mammoth-Leg-3844 [link] [留言]

I'm a software engineer who mainly builds softwaes/applications, and I'm starting to work on machine learning projects. Since ML workloads often require GPUs, I know services like Google Colab and Kaggle exist. but, I'm looking for something a bit different. Is there a platform where I can use AI coding agents (such as Codex, Claude Code, or OpenCode) while running the actual ML code on a cloud GPU? Ideally, I'd like to: Work locally with my preferred editor and AI coding agent. Have the code execute on a remote GPU machine. Be able to build, debug, and iterate on ML projects as if the GPU were attached to my local development environment. Does a setup like this exist? If so, what tools or platforms do you recommend? submitted by /u/Fickle_Degree_2728 [link] [留言]

How synthetic reality may influence human intuition about motion, gravity, and causality AI video generation has reached a point where a model can create scenes that look physically convincing at first glance: A person jumping impossible distances Objects moving without inertia Water flowing upward Animals performing human-like actions Buildings bending like rubber People interacting with impossible environments For decades, humans learned physics by observing the real world. A ball falls. A glass breaks. A person cannot walk through a wall. Heavy objects require more force to move. These observations create what cognitive scientists call intuitive physics : an internal mental model that predicts how objects should behave. But what happens when the majority of visual experiences become synthetic? Could AI-generated videos slowly change how future generations perceive reality? Humans Do Not See Reality Directly A common misconception is that our brain works like a camera: Reality → Eyes → Brain → Understanding The actual process is closer to: Reality ↓ Sensory input ↓ Brain prediction model ↓ Perception The brain is constantly predicting what should happen next. When you see a ball thrown into the air, your brain automatically predicts: trajectory speed gravity collision point acceleration This happens before conscious reasoning. This capability is known as predictive processing . Your brain is not only asking: "What am I seeing?" It is also asking: "Does this match my internal model of how the world works?" The Brain Learns Physics From Experience Young children do not learn physics from equations. They learn by interaction. A baby discovers: Objects continue to exist when hidden Unsupported objects fall Solid objects cannot overlap Larger objects require more effort to move Researchers call these abilities core knowledge systems . Humans appear to have an innate expectation that the physical world follows consistent rules. For example: A child watching a ball roll

I have been running some experiments with smaller open-weight LLMs on multiple-choice questions of Swedish medical licensing exams. On a dataset called MedQA-SWE, GPT-4 scored 84% accuracy in 2024 and o3 scored 88% in 2025 on a smaller, overlapping dataset. With post-training (SFT) on data from earlier years, I got MedGemma-1.5-4B to a passing score of 60% on the final year’s exam. Find the implementation here: https://github.com/tarolangner/medqaswe_medgemma_sft But even though they were released just three months later, Gemma4-E4B and Qwen3.5-4B are flat out superior already, at 77% with no post-training at all. With reasoning enabled, the latter can get to 87% accuracy. It can even push a bit further if no length cap is put on the reasoning traces, but some of them spiral into repetitive loops about formatting that fill the entire context length without giving any answer. Here, I found it helpful to use an ‘early exit’ thinking intervention proposed in the S-GRPO paper that simply injects a phrase and closes the thinking trace at a predetermined sequence length. I also tried their proposed reinforcement learning method to get shorter reasoning traces, but with only minor gains (probably somewhat underdimensioned training setup). Curiously, Qwen3.5-4B does all reasoning in English despite the Swedish prompt, questions and answer options. But it really seems like the language is no obstacle, even though it’s often estimated to be just 1% of LLM training data. I also have a more detailed write-up on the details and experiments here for anyone interested: https://tensorlabbet.com/2026/07/19/medqaswe_post_training/ submitted by /u/AccomplishedCat4770 [link] [留言]

AI-Driven Development: How Machine Learning is Reshaping Software Workflows in 2026 The software development landscape of 2026 looks almost unrecognizable compared to just a few years ago. Artificial intelligence has moved from being a novel assistant to a core pillar of the development workflow. Today, AI doesn't just autocomplete a line of code; it helps architect entire systems, automatically detects and fixes bugs before they reach production, and continuously learns from the organization's codebase to accelerate every phase of delivery. This article explores the key transformations and practical examples of how AI is reshaping software development in 2026. AI-Powered Code Generation and Completion By 2026, AI-powered code assistants have evolved far beyond simple autocomplete. Modern systems understand natural language requirements, project architecture, and even business logic. Developers can describe complex features in plain English, and the AI generates multi-file implementations, including dependency management, configuration, and tests. Example: Generating a REST API with AI A developer might request: "Create a FastAPI endpoint for user registration with email verification, rate limiting, and an asynchronous database call." The AI would produce: from fastapi import APIRouter , HTTPException , Depends from sqlalchemy.ext.asyncio import AsyncSession from app.database import get_async_session from app.models import User from app.schemas import UserCreate , UserResponse from app.services import create_user , send_verification_email from app.rate_limiter import rate_limit router = APIRouter ( prefix = " /auth " , tags = [ " auth " ]) @router.post ( " /register " , response_model = UserResponse ) @rate_limit ( max_requests = 5 , window_seconds = 60 ) async def register ( user_data : UserCreate , db : AsyncSession = Depends ( get_async_session )): existing_user = await User . find_by_email ( db , user_data . email ) if existing_user : raise HTTPException ( statu

There are a few reasons why problems from International Mathematical Olympiad function as a good benchmark for LLMs: - The problems are new, not included in the training data of any model - Hard math problems are quite a good proxy for general intelligence capability - These are complex multi-step tasks that can benefit from orchestration / harness engineering Results: Frontier models (sol and fable) were able to get perfect / nearly perfect score regardless of harness. For both sonnet and opus, the webapp performance was quite poor, improved by provider harness (claude code) and even further improved using AutoFyn, a customizable multi-agent harness we developed. Even with harness, we were not able to match the performance of the frontier models. Open weight model GLM performed roughly at the same level as sonnet without harness, and improved similarly with AutoFyn. Numerical scores are available in the attached paper below. https://preview.redd.it/fy4ayale5nfh1.png?width=2155&format=png&auto=webp&s=040e466171a2f9480d4d6578b34f4d930b41e292 Grading was done by a different frontier model as well as manual verification (we are former IMO medalists, able to sanity check the results). There were cases when the model claimed a false solution (on P3 by sonnet, for example), so hallucination issue still persists in a verifiable domain like math. On the hardest problem: P3's key reduction was missed by every sub-frontier model in every harness, including a 20-hour run that proved everything else and stalled at the identical step. The harness supplied retrieval and verification, not a key idea needed for the solution. Paper: https://github.com/SignalPilot-Labs/AutoFyn/blob/main/results/imo-2026/autofyn-beyond-model-imo26-report.pdf Audit Trails: https://github.com/SignalPilot-Labs/AutoFyn/tree/main/results/imo-2026 submitted by /u/pequalnp92 [link] [留言]

This was my Bachelor's Final Project: implementing YOLO26n inference completely from scratch using ARM64 Assembly Language and C, without relying on existing inference frameworks. The goal was to understand how modern neural network inference engines work at a low level and explore optimization techniques for faster and more efficient edge AI execution on Raspberry Pi 4. The implementation includes: * ARM64 Assembly Language + C inference engine * ARM NEON SIMD optimization * Winograd convolution * Optimized GEMM kernels * Cache-aware tiling * Custom ARM64 micro-kernels * Operator fusion * Attention mechanism * YOLO26 components: Conv, C3K2, SPPF, C2PSA, PSA, BottleNeck, and Detect I extracted the YOLO26n model parameters and redesigned the memory layout into a custom binary format optimized for the inference pipeline. The implementation produces correct object detection results, but the performance improvement was lower than I initially expected. I would appreciate feedback and suggestions from anyone about: * CNN inference optimization * ARM NEON/vectorization * Memory layout and cache optimization * Low-level neural network acceleration Repository: https://github.com/mohammad-ghaderi/YOLO26 Thanks for any feedback or suggestions. submitted by /u/Forward_Confusion902 [link] [留言]