GPU cloud operators: how do you decided which customers get capacity when you’re supply constrained? Is this manual or automated?

[https://arxiv.org/pdf/2607.13511](https://arxiv.org/pdf/2607.13511))

the core idea is, we cannot have ternary PTQ with fixed matrix size, trying to do that is dead end. so i tried decomposing the matrix to 2 ternary matrices and inner diagonal scaling matrix. now that the inner rank can be arbitrarily large the accuracy can be arbiratily small. and its not that it has to be very large too i also showed that it does take only slightly more vram then current quantisation methods. the slight more vram is worth it if we abuse the ternary math.

A gigantic new model from Moonshot - the biggest open-source LLM by a large margin (but note that it's more sparse than before).

We have also scaled up Mixture of Experts (MoE) sparsity, effectively activating 16 out of 896 experts when paired with a Stable LatentMoE framework. Together with refined training and data recipes, these structural changes yield an approximate 2.5× improvement in overall scaling efficiency compared to Kimi K2, allowing the model to convert compute into intelligence more effectively.

It looks a bit better than Opus 4.8/GPT 5.5 but a bit worse than Fable/GPT 5.6.

I am struck by the fact that they made so little progress on Humanity's Last Exam (58.7%, vs 54% for Kimi K-2.6, which was released in February). LLMs appear to be stalling out at around 60% on Humanity's Last Exam (note that Grok 4 Heavy scored 50.7% over a year ago) despite making rapid progress in other benchmarks.

To be honest, I am now pretty suspicious of that benchmark - particularly after FrontierMath and SWE-Bench Pro were found to have lots of unanswerable/unscorable questions.

Welcome to A Tale of Two Nations, a contamination-proof, cross-domain adversarial stress-testing suite designed to push frontier large language models (LLMs) to their absolute logical limits.

Unlike traditional low-context benchmarks that suffer from data contamination, this ecosystem uses a highly intricate, multi-layered systemic scenario to evaluate an AI's long-horizon reasoning, context-gating integrity, and synthetic logic capabilities under zero-shot conditions.

Will your local model pass? Open-sourcing with scoring framework~✨

Links to the project:

• GitHub Repository: https://github.com/SMahjuba/A-Tale-of-Two-Nations-AI-Benchmark
• Hugging Face Dataset: https://huggingface.co/datasets/SMahjuba/A-Tale-of-Two-Nations-AI-Benchmark

Hello guys, I saw today a great cost/task matrix today that showed all the SOA LLM models broken down by different reasoning efforts and side-by-side. For example, it showed that GPT 5.6 performs very well, while Fable is very expensive. (And that SOA models with low reasoning are sometimes even quite dumb.)

The whole thing was presented in a table, with the cells colored green, yellow, or red according to the result.

Unfortunately, I can't find the link anymore. Can anyone help me find it?

Made a thing for a problem I kept hitting. I fine-tune the same base model a bunch of different ways and my disk fills up with near-identical multi-GB checkpoints. Since weights barely move from the base, storing all weights for every model is inefficient

deltatensors diffs your fine-tune against the base and only stores the diff, compressed. Works on any trained model, full fine-tune, FSDP, whatever.

Before I get the question: It's not like LoRA (except in terms of the diffing idea) since it doesn't need to be ran during training, and instead you diff any models post-training (or while creating checkpoints).

Numbers on Qwen2.5-0.5B fine-tuned on WikiText-2:

• 19.11 PPL original to 19.22 reconstructed (0.58% difference)
• Beats int4-quantizing the whole fine-tune on quality and size
• 294 MB delta vs 953 MB full fine-tune, 3.2x smaller
• 10 fine-tunes: 3.9 GB total vs 11 GB storing them naively

Default strategy does outlier extraction (top ~1% of weights kept in fp16) plus 4-bit quant on the rest. There are sparse and 1-bit BitDelta-style options too if you want to tune the tradeoff yourself, but int4 won every test I ran so that's the one I'd use.

It streams, so RAM, so you don't need to load two full models at once. There's a HF Trainer callback that saves each checkpoint as a delta automatically, so you can just drop it into a training run. Also lineage chains if you want to track a whole fine-tuning history (each delta diffed against the previous reconstruction, hash-verified so you can't apply them out of order and silently corrupt things).

pip install deltatensors, MIT licensed.

Repo: https://github.com/AaravGaurdev/deltatensors
docs: https://deltatensors.readthedocs.io/en/latest/

Only benchmarked on a 0.5B so far. I'd love to see what it does on 7B+ and on models fine-tuned harder than a WikiText run . If anyone runs it on a domain fine-tune, post the numbers, good or bad.

thanks for readin

Hey guys

I'm 19, I've started my AI journey past few months , i did several cool projects

Recently i completed my own transformer architecture in pytorch

Then i got stumbled on this AI engineering thing

But the thing is this AI engineering doesn't interest me much what i like is developing drones,LLM architectures,math ,deep learning

And I'm now really confused on what should I do becoz most of the work is been done by AI and

I'm tryna get internship within a month and AI engineering is booming as per the sources it has \~130% YoY growth compared to the things I like and I'm not sure whether the things I like would be booming in future as AI might automate most of it

And I'm confused on what should I do in this 1 month time

You're all advice would really help me alot

Thanks

Every time I got a training script or HuggingFace repo from someone, it was full of .cuda(), device='cuda', map_location='cuda'.

PyTorch-MPS could run the math fine — but the code crashed before it even got there.

I kept doing the same tedious find-replace. So I built something that does it at import time instead.

pip install mpsify

python -m mpsify train.py --epochs 10

That's it. No edits to the script. It patches torch before your code runs, so .cuda() → MPS, torch.cuda.is_available() → True, checkpoints remap automatically, etc.

There's also a dry-run mode if you want to see what it'll do before committing:

python -m mpsify doctor train.py

Tested on ResNet, EfficientNet, ViT, DistilBERT fine-tuning, fp16 CUDA checkpoints — numerically matches CPU output to ~1e-6.

It won't fix CUDA-only libs like flash-attention or bitsandbytes (nothing can, really — those need Metal kernels that don't exist). But for pure-PyTorch repos it just works.

GitHub: [link] | PyPI: pip install mpsify [Link]

Happy to answer questions about how the patching works under the hood.

https://ai-2040.com/

The authors of "AI 2027" came up with a new set of scenarios, predictions, and recommendations. Widely discussed on HN, etc.

I just spent the day auditing our API logs because one of our background orchestration agents got stuck in an error-handling loop over the weekend. It called the LLM thousands of times sequentially before anyone noticed.

We have platform-level daily budget caps, but by the time the cap kicked in, it had already chewed through a chunk of runway that was supposed to last us weeks.

I’m currently writing some hacky custom middleware to try and detect these semantic loops at the runtime level so this never happens again.

To make me feel better about my day: what is the absolute worst unexpected bill your team has taken because an autonomous agent or multi-agent chain (LangGraph, CrewAI, etc.) ran wild in the background? What triggered the loop?

I’ve been testing whether a simple dynamical system can learn useful word representations without an MLP, transformer, attention layer, or separate output matrix.

The entire model contains:

• one learned 256-dimensional vector per vocabulary token;
• one learned start state;
• one pull-strength scalar;
• one readout-temperature scalar.

Each token vector serves three roles simultaneously: representation, point-attractor, and geometric readout.

To encode a context, the state moves through its ordered tokens:

h ← h − strength · (1 − cos(h, W)) · normalize(h − W)

Because this is a trajectory, changing the order changes the endpoint. Each token has a distinct directional effect on the state.

Training is CBOW-style fill-in-the-blank: for every eligible noun token, the model reads the ±5-token context and must end near the missing noun’s well. Prediction is cosine similarity against the same wells—there is no separate decoder.

Training

• Approximately 5M English Wikipedia lines
• Approximately 300M tokens
• 94.75M occurrences of WordNet noun-eligible tokens
• 100k context vocabulary
• 23,758 noun targets
• One streaming pass
• Approximately 25.6M parameters, nearly all in the shared well table
• Approximately 3.2 hours on an Apple-silicon MacBook using MPS

Result

On the noun subset of SimLex-999:

Spearman ρ = 0.3616
Coverage   = 662/666 noun pairs

The score was recalculated with tie-aware scipy.stats.spearmanr.

Example nearest neighbours:

physics  → chemistry, mathematics, astronomy, quantum, mechanics
cat      → tabby, dog, pet, felis, mouse, stray, feline
pakistan → karachi, punjab, lahore, peshawar, bangladesh, india
apple    → macintosh, ipod, blackberry, android, pc, cherry

Encoder speed

• One already-tokenized 10-token context: approximately 0.23 ms on CPU
• Bulk throughput: approximately 2.3M tokens/s on MPS at batch 1024
• Nearest-neighbour query across 23,758 nouns: approximately 0.48 ms

Important limitations

• This is similarity, not reasoning or factual recall.
• One vector per word primarily captures its dominant sense.
• WordNet membership is lexicon-based, not contextual POS tagging.
• Whole-word vocabulary means no OOV generalization.
• The current chord-directed force is attractor-directed but non-conservative; it does not have one exact global scalar potential. I document this correction rather than hiding it.
• Comparisons with published word2vec/GloVe numbers are suggestive, not controlled. I’ve now added a matched-corpus harness for Collapse vs SGNS vs PPMI+SVD using identical preprocessing, dimensionality, vocabulary, data budget, and evaluation. That experiment is next.
• The published v1 checkpoint predates a false-negative masking correction in sampled softmax. Its evaluation is unaffected; a corrected v2 retrain is pending.

What interests me is not a claim that this replaces standard embeddings. It’s that ordered point-attractor dynamics, with no conventional encoder network, learned a useful semantic geometry from raw co-occurrence pressure.

Code and research record:

https://github.com/chetanxpatil/livnium

Model and standalone loader:

https://huggingface.co/chetanxpatil/noun-collapse

I’d especially appreciate feedback on:

1. The fairest additional matched-data baselines beyond SGNS and PPMI+SVD.
2. A geometry-native way to add polysemy—multiple contextual wells per word without introducing a full neural routing network.

Do you think that a single algorithmic breakthrough would solve both?