标签：#MachineLearning

The shifts that actually matter for builders - late May to mid-August 2026 The last three months did not produce a single "GPT-5 moment." There was no single release that reset the conversation the way earlier step-changes once did. Instead, the ground moved in several places at once: a wave of frontier and open-weight model launches in July, growing candor about how badly long-context windows actually hold up, and a genuinely uncomfortable security story out of xAI's new agent product. Here's the short, opinionated version of what actually changed for people who ship AI systems. 1. Models & Capability GPT-5.6 (OpenAI) shipped in three tiers - Sol, Terra, and Luna after a government review, with the fastest tier reportedly hitting 750 tokens/sec on Cerebras hardware and a new "Ultra" mode for maximum reasoning effort. Anthropic's lineup grew fast: Opus 5 landed at unchanged Opus pricing ($5/$25 per million tokens), reportedly within half a point of a rival's benchmark peak at half the per-task cost, alongside a new Sonnet 5 and a higher "Fable 5" tier. xAI iterated twice: July's Grok 4.5 (1.5T parameters, trained partly on coding-agent interaction data) was followed by Grok 4.6 on August 12 - a 500K-token-context model aimed at coding and long-running agents, priced at $2/$6 per million tokens standard and $4/$12 for long-context requests. Google's Gemini Flash line saw three releases in quick succession - 3.5, 3.6, and then 3.7 Flash - each undercutting the last on price. 3.6 Flash alone cut output pricing from $9.00 to $7.50 per million tokens. Open-weight competition intensified: Kimi K3 (Moonshot) became the largest open release yet at 2.8T parameters (104B active via MoE) with a 1M-token window, and it was joined by DeepSeek V4-Pro, the Qwen3.8 series, and GLM-5.3 - plus Inkling (Thinking Machines), a 975B open-weight MoE trained on 45 trillion multimodal tokens. One-line interpretation: The capability ceiling is still rising, but the more interesting number th

Recently, the AAAI 2027 organizers sent an email regarding collusion occurring during the review process, especially in the 2-cycles category (i.e., an author of Paper A reviews Paper B, while an author of Paper B reviews Paper A). Given the fact that most submissions come from a single country, there are higher chances that the assignment algorithm will naturally create 2-cycles among authors from that country. This, in turn, means that most authors involved in collusion could be from that country. I will not name that country; otherwise, I would be labelled as racist. By the way, did AAAI release statistics about the number of submissions, like they did last time? It is also good news that a major and prestigious conference like AAAI is acknowledging that collusion is happening. We all knew that this kind of collusion had been happening for years. There are papers accepted at top conferences such as NeurIPS, ICLR, AAAI, and ICML that do not even have their code published on GitHub. This forces other researchers in the community to spend substantial time reimplementing the code themselves if they want to reproduce the reported results. What are the views of other authors on this? submitted by /u/Fragrant_Fan_6751 [link] [留言]

Does anyone know how the BMVC to IJCV special issue recommendation works? Is it mainly based on the review scores, or is it a separate decision by the ACs/program chairs (e.g. based on oral/highlight selection, reviewer comments, etc.)? Also, is there any way to know at this point whether a paper has been recommended for the IJCV track, or do authors only find out later through a separate email? Would be great to hear from anyone who has gone through this in previous years! submitted by /u/Secondhanded_PhD [link] [留言]

This is a simplified guide to an AI model called Beat_this maintained by Xavriley . If you like these kinds of analysis, you should join AImodels.fyi or follow us on Twitter . Overview beat_this is a beat and downbeat tracking model from the ISMIR 2024 paper "Beat This! Accurate Beat Tracking Without DBN Postprocessing" by xavriley and collaborators at CPJKU. The model detects precise beat positions and downbeat boundaries in audio files without relying on Dynamic Bayesian Network postprocessing, achieving state-of-the-art F1 scores while maintaining generality across diverse music genres. The architecture alternates convolutions with transformers operating either over frequency or time dimensions, and is trained on multiple datasets including solo instruments, pieces with time signature changes, and classical music with high tempo variations. The main model ( final0 , final1 , final2 ) weighs approximately 78 MB each, with a smaller variant available at 8.1 MB. The most critical detail before using it: the model achieves good results specifically because it avoids meter and tempo constraints that traditional systems impose, but this means it can still fail on difficult and underrepresented genres and performs worse on continuity metrics compared to methods using postprocessing. Best use cases Music information retrieval and analysis workflows. If you build music analysis software that needs to segment tracks into beat-aligned sections for tempo detection, structural analysis, or synchronization with other modalities, beat_this provides clean beat and downbeat annotations without requiring external postprocessing pipelines. The model outputs precise timestamps suitable for downstream music information retrieval tasks like onset detection or harmonic analysis. Rhythm-aware music production tools. For digital audio workstations, beat detection plugins, or metronome applications, this model provides frame-level accuracy suitable for real-time audio alignment and grid s

La forma del problema Un directorio es una superficie: el miembro lo abre y adivina. Un recomendador es una superficie de empujar: el sistema propone y tiene que justificarse. La justificación es la parte difícil, y es donde vive la estadística. Tres restricciones hicieron esto distinto de un recomendador de contenido: El item es una persona con capacidad finita. Un hilo se le puede recomendar a diez mil personas. Un experto no. Una mala recomendación es cara de los dos lados. Quien pide desperdicia una petición, el experto desperdicia una hora, y los dos aprenden a ignorar la superficie. La afirmación tiene que ser checable. "Quizá te guste este hilo" no necesita evidencia. "Esta persona está un nivel adelante de ti en diseño de sistemas" sí. Recuperación: híbrida, fusionada con RRF Tres recuperadores independientes sobre el conjunto de expertos elegibles, fusionados con Reciprocal Rank Fusion: def rrf_fuse ( * ranked_lists , k = 60 ): """ Fusiona listas de ids rankeadas. El score depende solo del rank, nunca de la escala propia del recuperador, que es el punto: la similitud coseno y un conteo de hilos resueltos no son números comparables. """ fused = {} for lst in ranked_lists : for rank , key in enumerate ( lst ): fused [ key ] = fused . get ( key , 0.0 ) + 1.0 / ( k + rank ) return fused RRF es la primitiva correcta aquí por una razón que vale la pena decir: los recuperadores emiten cantidades incomparables. Uno regresa un coseno en [-1, 1] , uno regresa un conteo entero de hilos resueltos, uno regresa un delta de nivel de escalera. Normalizarlos a una escala común requiere supuestos sobre sus distribuciones que nadie tiene a este volumen de datos. RRF descarta las magnitudes y se queda solo con el orden, que es exactamente la información que sobrevive a una muestra chica. k = 60 es la constante estándar de la formulación original de Cormack et al. Aplana la cabeza: la diferencia entre el rank 1 y el rank 2 es 1/61 - 1/62 ≈ 0.00026 , así que un recuperador no pu

Over the past year I have been fine-tuning open vision-language models - 9B dense up to a 35B mixture-of-experts - with supervised fine-tuning and GRPO-style reinforcement learning on verifiable rewards. Most of what I learned was not about algorithms. It was about the ways a training run can look healthy while doing nothing, or crash for reasons that have nothing to do with your code. Three failures, in increasing order of how long they fooled me. Failure 1: the metric that measured the wrong thing (18 hours) I ran an 18-hour supervised fine-tune that reported token accuracy climbing steadily to 99%. Looked like a textbook run. The real evaluation metric - accuracy on multiple-choice questions - never moved. The cause was a mismatch between what I supervised and what I evaluated. The training loss was over free-text reasoning traces; the evaluation scored a single extracted answer letter. The model got extremely good at reproducing the shape of the training text - hence 99% token accuracy - without that transferring to the decision I actually cared about. Token accuracy is a proxy, and proxies drift from the target exactly when you stop checking. The fix was structural, not a hyperparameter: supervise the thing you evaluate. If the deliverable is a constrained answer, the training signal has to reach that answer, not just the prose around it. The general rule I took: any training metric that is not your evaluation metric is a hypothesis about correlation, and you should check that correlation before you spend GPU-days on it. Failure 2: the crash that was two libraries disagreeing about position ids The GRPO trainer for the 9B vision model crashed in the forward pass, deep inside rotary position embedding code. Nothing in my training code had changed. The diagnosis took a while because the bug lived at the boundary between components: the text sequence length was derived from token-type ids, while the vision sequence length came from the image grid - and image-pad t

Small language models can now run directly on phones. But most of them stop learning the moment they ship. For personal AI, that feels like a strange stopping point. Some of the most useful signals arrive only after the model acts: Did the user dismiss the notification? Did they open it later? Did they rewrite the suggestion? Did they ask for it again? These interactions contain useful information about the user, but they are delayed, private, and ambiguous. They are not clean labels, and they are not reliable scalar rewards. To explore this problem, we built Online-SDFT , an open-source prototype that continually fine-tunes a small language model from delayed interactions while keeping the learning loop on the device. The prototype uses: LiquidAI/LFM2.5-230M A rank-4 LoRA adapter ONNX Runtime Training A bounded on-device replay buffer An Android notification-routing testbed Once the model has been provisioned, inference, interaction storage, replay, and adapter updates all happen locally. Why standard fine-tuning is awkward here Suppose the model receives a notification and chooses one of three actions: Show it now Save it for later Archive it Supervised fine-tuning would require a correct action for every notification. But the phone never observes what the ideal action was. Reinforcement learning replaces the correct answer with a reward, but that reward is also difficult to define. Opening a notification does not necessarily mean it arrived at the right time. Ignoring it does not necessarily mean it was unimportant. The user may simply have been busy. There is another complication: the model only observes the result of the action it actually took. If it archives a notification, it cannot know what would have happened had it shown the notification immediately. What the phone receives is not a label or reward. It receives hindsight . Using the same model as student and teacher The core idea is simple: let the model reconsider its decision after seeing what happened

Electric-vehicle assistants rarely have just one job. A short Turkish question may ask for a nearby station, a charging-price comparison, help planning a route, or an explanation of battery health. Before an application can retrieve current data or generate an answer, it needs to identify that intent reliably. We created the Turkish EV Charging Intent Dataset as a small, transparent starting point for that routing problem. Version 1.0.0 contains 192 Turkish queries distributed evenly across eight intent classes. It is open under CC BY 4.0, includes fixed train, validation, and test splits, and is maintained by TekPedal , an EV charging map and vehicle decision platform for Türkiye. You can explore the dataset interactively , inspect the source and validation workflow on GitHub , or cite the permanent Zenodo release with DOI 10.5281/zenodo.22062688 . Why intent routing comes first An assistant should not answer every EV question in the same way. Different requests need different tools and freshness guarantees: a station request needs a map or location index; a price request needs current tariff data; route planning needs distance, range, and charging-stop logic; a battery question needs careful educational content; a vehicle comparison needs structured specifications. An intent router makes that separation explicit. It can send each query to the correct retrieval source, product page, or application workflow. This also makes evaluation easier: teams can test routing independently before measuring the quality of downstream answers. Dataset design The taxonomy contains eight balanced classes, with 24 records in each class: FIND_STATION COMPARE_PRICE ROUTE_PLANNING CHARGING_SPEED VEHICLE_COMPARISON HOME_CHARGING BATTERY_HEALTH OWNERSHIP_COST Every record includes a stable ID, the Turkish query, the intent identifier, a human-readable Turkish label, a suggested TekPedal content route, the assigned split, the language, and a provenance marker. Here is a simplified example

I had a paper accepted to a conference. This paper was originally published as a preprint. Subsequent works citing our preprint focused on the same topic and reused/extended our methodology. I am now preparing the camera-ready version of that preprint and I'm wondering how I should deal with this for the Related work section. It seems odd to me to cite my own preprint for the camera-ready version of the paper (and I am not even sure if this is allowed), but at the same time, I don't want to undermine the novelty of my original work (nor undermine the efforts of subsequent works). Has anyone dealt with such a situation before? What's the best way of solving this? submitted by /u/Vulcapulae [link] [留言]

Never attended a conference before, so apologies if these are dumb questions. I’m an author of an accepted paper at COLM 2026. One of my coauthors registered during the author-only registration period, so I joined the waitlist on August 10. I later received an email saying: “Your access to reserve tickets remains active until Aug 24 7:06 p.m. EDT.” I thought I had until August 24 to register, so I didn’t register immediately. When I checked again today (8/23), registration was sold out. I also can’t seem to rejoin the waitlist. Unfortunately, I also missed the financial assistance deadline because at the time I wasn’t even sure whether I would be able to attend. I really really want to attend the conference. Does anyone know what I can do at this point? Is there a chance that more registration spots will be released later? And is there any possibility of getting financial assistance after the deadline? Thanks a lot for any advice. submitted by /u/mziycfh [link] [留言]

My dumbass just realized all NeurIPS workshops are non-archival. In terms of grad school applications, would there be a difference in how much they value ur paper if u get it in a proceeding submitted by /u/Wonderful_Entry9371 [link] [留言]

been building ShardFlow for the past few months, a distributed LLM inference framework that splits any HuggingFace transformer across N GPU machines and uses neural speculative decoding to deal with WAN latency. the setup for the benchmark: two T4 nodes in separate GCP regions (Iowa + Oregon) talking through an AWS EC2 TCP relay in Ohio. ~86ms RTT on public internet. the key insight with speculative decoding here is that WAN latency stops being a per-token cost and becomes a per-round cost. with K=8 drafting you're committing 4.07 tokens per round trip instead of 1. at 86ms RTT that's a big deal. numbers on Qwen2.5-7B: non-speculative baseline: 4.92 TPS neural drafter (eager): 14.3 TPS peak + CUDA Graphs on drafter: 28.10 TPS peak / 20.31 TPS avg also ran Qwen2.5-14B with NF4 4-bit quant, same two nodes: 14.43 TPS avg. the v2.1 fix that surprised me most: draft generation was launching ~1500 CUDA kernels per round from a Python loop. each kernel 2-5us, Python launch overhead 8-10us. GPU sitting idle 65% of the time. capturing the full 0.5B forward pass as a CUDA Graph and replaying with one driver call dropped draft latency from 112ms to 25ms. other things in the stack: zero-copy Rust TCP relay, StaticCache + in-place KV rewind for graph compatibility, meta-device model slicing to avoid loading 15GB into CPU RAM. repo: https://github.com/rautaditya2606/Shardflow happy to answer questions on the speculative decoding implementation or the CUDA graphs stuff specifically. submitted by /u/katua_bkl [link] [留言]

The last post was about making a number trustworthy. Leakage geometry, purge widths, de-overlap, a baseline that could not cheat. It ended with a minute-scale ceiling that held at 52% across seven configurations and a model family swap. This one is about what happens after you trust the number. Because a probability you are going to bet on is a different object from a probability you are going to report. The probabilities are not decorative The path-passage classifier is a three-class LightGBM. It returns p_up , p_down , p_none . Those go straight into the expected-value score that decides whether to take a trade and how big: long_score = p_up * ( B - C ) + p_down * ( - B - C ) + p_none * ( - C ) short_score = p_up * ( - B - C ) + p_down * ( B - C ) + p_none * ( - C ) B is the barrier, C the cost. Read the arithmetic. Every term is linear in a probability. Scale p_up by 1.2 and you scale the long score by very nearly 1.2. So miscalibration does not stay in the model. It becomes a bet-sizing error, in proportion, in the bins where the gate actually fires. A classifier that is right 70% of the time while claiming 90% is not 20 points wrong. It is sizing every position in that bin as though the edge were far larger than it is. Boosted trees are known for uncalibrated softmax output. I had been consuming it as if it were a probability. The audit Seven live assets. For each one, fit an Inductive Venn-Abers wrapper on the time-ordered older 80% of that model's training data, 6,988 rows, and evaluate against a 500-row uniform-random sample of the newer 20%, seed 42. The LightGBM models are reloaded from disk and left alone. Only the wrapper is fit. Measure Expected Calibration Error and log-loss, before and after. Asset ECE before → after ECE Δ Log-loss Δ BTC 0.1272 → 0.0621 -51.2% -5.5% ETH 0.1795 → 0.0298 -83.4% -11.5% SOL 0.1680 → 0.0386 -77.0% -10.6% XRP 0.2219 → 0.0645 -70.9% -17.7% ADA 0.1419 → 0.0369 -74.0% -8.0% LINK 0.1260 → 0.0737 -41.5% -1.2% LTC 0.1508 → 0.0603

Hi! I'm one of the chairs of the EACL 2027 Industry Track , so flagging the deadline here — it's about three weeks out and this community has a lot of people doing exactly the kind of work the track exists for. The EACL 2027 Industry Track provides the opportunity to highlight key insights and new research challenges that arise from the development and deployment of real-world applications using language technologies . We encourage submissions from industry, non-profit, government, and public-sector organisations, with the understanding that the end-users of these systems extend beyond the NLP community. See the Full CFP for the details https://2027.eacl.org/calls/industry/ ** Deadline: ** 11 September 2026, 23:59 AoE ** Length: ** 6 pages max; references, limitations, ethics, and appendices don't count. A dedicated "Limitations" section is mandatory — papers without one are desk rejected. ** Review: ** double-blind. No anonymity period, so arXiv preprints are fine. ** Proprietary data: ** no requirement to release it ** Notification: ** 18 December 2026. Conference is 9–14 March 2027. ** Submit: ** https://openreview.net/group?id=eacl.org/EACL/2027/Industry_Track We're also looking for reviewers — if you've got deployment experience and want to help, the volunteer form is here: https://forms.gle/TT6N2gtuoV5P3oYi6 Email: [ eacl2027-industry-track@googlegroups.com ](mailto: eacl2027-industry-track@googlegroups.com ) submitted by /u/kochkinael [link] [留言]

I recently implemented a minimal, educational version of SynthID-Text-style watermarking for language models. I saw anthropic post about how they'll start adding watermarks to their model responses and it made me very curious as to how they'll do it and what do they even mean by watermark here. Like will we start getting random ads or something in the middle of model responses or what. Then decided to read their article and found out that watermark is not a visible message at all. It is a subtle statistical pattern introduced while the model chooses its tokens. My implementation is not an exact reproduction of the original SynthID-Text system. I simplified or implemented a few components differently to keep the project understandable, but the main idea is there I think. Github: https://github.com/Saad1926Q/llm-watermark If you find it interesting then you may star the repo !! submitted by /u/Saad_ahmed04 [link] [留言]

I was staring at a broken Next.js and Express backend integration late at night, convinced my AI agent had lost its mind. It was supposed to be a straightforward n8n automation pipeline. Yet, every time it ran, it hallucinated non-existent packages and dumped its context halfway through. My System 1 intuitive reaction flared up immediately: The LLM just isn't smart enough. I sat there, exhausted, ready to rewrite the prompt for the twentieth time. Engaging System 2 Taking a step back, I forced myself to engage my analytical System 2 brain. I wasn't dealing with a lack of model intelligence; I was dealing with a lack of infrastructure. I was running a massive, powerful AI model with zero guardrails. No persistent memory. No verification. Just dumping a giant Mongoose schema into a prompt and hoping for the best. I was essentially dropping a Formula 1 engine onto a wooden skateboard and wondering why it crashed at the first turn. What is Harness Engineering? I stopped obsessing over prompt engineering and started focusing on Harness Engineering. The model is just the engine; the harness provides the chassis, the steering, and the brakes. Here is how I completely restructured my agentic workflow: Context Management: Instead of flooding the context window with raw codebase dumps, I implemented targeted retrieval. The agent now only sees the specific files required for the immediate task. Standardized Tools: I integrated Model Context Protocol (MCP) servers, giving the model bounded, secure ways to execute actions rather than just generating text. Durable State: If a long-running workflow pauses or fails, the system now checkpoints its progress. It resumes exactly where it left off instead of starting from scratch. Strict Verification: "Looks good to me" is no longer an acceptable output. The agent is forced to run tests and verify the CLI output before concluding a task. Learn to Break the System The results were immediate. The hallucinations stopped, and the agent shif

Hey everyone! I wanted to share something I’ve been working on. I was inspired by projects from DeepMind and OpenAI, but noticed that most games are prohibitively difficult to integrate with an agent harness. So I built DelveRL from the ground up as a human-playable game with a structured API, deterministic simulation, procedural levels, partial observability, and enough strategic headroom for agents to compete and improve. It’s an endless turn-based roguelike where agents must explore, manage risk and resources, fight enemies, and escape each floor. Everything runs locally, including batched renderer-free environments and a recurrent PPO trainer. The included baseline reaches a median floor of 18, with extended runs reaching floor 33. The game, training code, checkpoint, bridge documentation, and raw benchmarks are all open source. I’d love to see what approaches people try - and how quickly the baseline gets crushed submitted by /u/SnyderConsulting [link] [留言]

The preprint can be accessed via the following link: https://arxiv.org/abs/2608.12408 (q-bio.NC / cs.LG). And for the code: https://github.com/nilsleut/evaluation-resolution-rsa The following assertion is frequently made in model-brain comparisons: untrained convolutional neural networks (CNNs) have the capacity to match or surpass backpropagation-trained CNNs at the early visual cortex (V1) in representational similarity analysis (RSA). The present study demonstrates that this phenomenon is predominantly an artefact of evaluation resolution. The configuration comprised a small CNN trained at 32px (CIFAR-10 subset), five learning rules (random init, backprop, feedback alignment, predictive coding, STDP), and was evaluated on THINGS-fMRI stimuli at six resolutions from 32px to 224px. The weights and normalisation were held fixed. The primary outcome of this study is the observed gap between the untrained and backpropagation-trained (BP) V1 alignment, which widens monotonically across the range of evaluation resolutions examined. Specifically, the gap grows from −0.001±0.007 at 32 pixels to +0.044±0.006 at 224 pixels, a pattern that holds consistently across the entire resolution sweep (n=5 seeds). The result holds across five rule conditions, human fMRI, directionally single-seed macaque ephys, the full training trajectory, and two off-the-shelf 224px-trained models (ResNet-50, Swin-Tiny). Therefore, an artifact resulting from a mismatch between training and evaluation resolution is not a contributing factor, since these models also peak at low resolution. Following the implementation of bit-identical-weight interventions wherever possible, the following were ruled out: train/eval resolution matching, Gabor/pixel low-level structure, the untrained baseline's uncalibrated batch-norm, and convergence of pooled features towards global brightness (though a single scalar luminance value did reach ρ=0.075 against V1, essentially matching the untrained network's own 0.076 —

I have got two papers which got desk rejected by PC saying they are previously got reviewed in arr. But those paper never got submitted ever. Any idea what can be done? submitted by /u/malakulmout347 [link] [留言]

I am trying understand how tree-based regression model handle the dependencies of the target variables on the interaction of explanatory variables. However my experiment revealed that my understanding about the fitting process of a lgbm is not correct. And I don’t know why. My experiment is quite simple: a target (for sake of simplicity only in [0, 1]) and two explanatory variables with two values such that the mean of the target is the same for each of the values of the explanatory variables. Then there is a third variable that models the interaction of the explanatory variables by a simple count. So in code: >>> import polars as pl df = pl.Dataframe( { „y“: [0, 0, 1, 1, 0, 0, 1, 1], # mean across „A“ values the same; mean across „B“ values the same „A“: [1, 1, 1, 1, 0, 0, 0, 0], „B“: [1, 1, 0, 0, 1, 1, 0, 0], „AB“ [1, 1, 2, 2, 3, 3, 4, 4] # just some IDs for the interaction } ) <<< I then fitted a lgbm just with „A“ and „B“ and got the expected constant 0.5 forecast >>> from lightgbm import LGBMRegressor lgbm = LGBMRegressor(min_child_samples=1) lgbm.fit(df[[„A“, „B“]].to_numpy(), df[„y“].to_numpy()) lgbm.predict(df[[„A“, „B“]].to_numpy()).round(0) array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]) <<< Then I did the same but with „AB“ and expected a perfect fit. But I was disappointed, it fitted to constant zero >>> lgbm = LGBMRegressor(min_child_samples=1) lgbm.fit(df[[„AB“]].to_numpy(), df[„y“].to_numpy()) lgbm.predict(df[[„AB“]].to_numpy()).round(0) array([0, 0, 0, 0, 0, 0, 0, 0,]) <<< I tried to code „AB“ as category. But still no perfect fit: >>> lgbm = LGBMRegressor(min_child_samples=1) lgbm.fit(df[[„AB“]].to_numpy(), df[„y“].to_numpy()) lgbm.predict(df[[„AB“]].to_numpy()).round(0) array([0, 0, 1, 1, 0, 0, 0, 0,]) <<< Super confusing! I then turned to catboost and found even without „AB“ it fit the data perfectly: >>> from catboost import CatBoostRegressor cbm = LGBMRegressor(min_data_in_leaf=1) cbm.fit(df[[„A“, „B“]].to_numpy(), df[„y“].to_numpy()) cbm.predic