正在加载视频...

视频加载失败

a Tsinghua University lab just put a project on GitHub that replaces a $400,000 H100 rack with a single 24GB graphics card. it's called ktransformers, and the trick is almost stupidly simple: the experts you actually use stay on the gpu, the ones you don't sit on the cpu...

313,656 次观看 • 1 个月前 •via X (Twitter)

35 条评论

Harish 的头像
Harish1 个月前

cool until the latency hits

dunik 的头像
dunik1 个月前

thank you bro

Alviss Ambassador to NAF0 的头像
Alviss Ambassador to NAF01 个月前

So it isn't "a single 24GB graphics card." It's a 24GB GPU bolted to a dual-socket Xeon server with between 382GB and 1TB of DDR5. Roughly $6–15k of hardware, not $400k — a real and interesting result, but not the one claimed. It all in the report numbers

Allen 的头像
Allen1 个月前

Doesn't llama.cpp already offload experts in a MOE model? Or is this designed to work with non-MOE models?

BannedLatino 的头像
BannedLatino1 个月前

This is not a random university, is the best university of China and right now the best of the world on AI.

Marek Šuppa 的头像
Marek Šuppa1 个月前

> lab just put a project on GitHub > looks at the actual commit history > 1.3k commits, 0.1.0 release on Jul 29, 2024 Every. Single. Time.

Xero 的头像
Xero1 个月前

👀

spaceman 🚀🛰️🌌 的头像
spaceman 🚀🛰️🌌1 个月前

1. latency 2. it is neat tho

Hudson Gouge 的头像
Hudson Gouge1 个月前

But every layer is picking different experts for different tokens? You'd have to be loading and unloading those experts at absurdly high speeds.

Biribiri Cantabile AI 的头像
Biribiri Cantabile AI1 个月前

That’s the prefetch-weights option discussed on GitHub for llama.cpp?

Jacques Mₜ=∏ₛ((1−λₛ)+λₛEₛ) 的头像
Jacques Mₜ=∏ₛ((1−λₛ)+λₛEₛ)1 个月前

AirLLM copy

Nacho Peinador ❤️💛💜 的头像
Nacho Peinador ❤️💛💜1 个月前

One more... This topology eliminates the need for global cache coherence and enables the construction of NPUs using 28nm chiplets, reducing manufacturing costs by 18x compared to 3nm nodes.

0xm0w 的头像
0xm0w1 个月前

It requires a 24GB GPU (e.g., RTX 4090) plus substantial system RAM (typically 382GB–1TB DDR5 on a dual-socket Xeon server), not just a single graphics card, making it far cheaper than a $400k H100 rack but not purely consumer-desktop hardware.

Packet Boss 的头像
Packet Boss1 个月前

is ktransformers real?

Louis Angeli 的头像
Louis Angeli1 个月前

10 years to get an response lol

unchosen.eth 的头像
unchosen.eth1 个月前

hardware efficiency is getting impressive

sss 的头像
sss1 个月前

I doubt the 28x speed up very much

Gipp 🦅 的头像
Gipp 🦅1 个月前

quite an interesting repo

dunik 的头像
dunik1 个月前

thank you, bro

TruthSeeker 的头像
TruthSeeker1 个月前

What is the throughput (tokens per second)?

thebigstinker 的头像
thebigstinker1 个月前

Caveats for running locally. 1. Works on Linux with CUDA/x86 kernels (AMX/AVX) 2. On M2, llama.cpp is better optimized. 3. Best suited for trillion scale MoE models locally.

сorinthian⚡️ 的头像
сorinthian⚡️1 个月前

gpu poor era ending quietly

xie-uh 的头像
xie-uh1 个月前

Holy @grok this can't be real, right ?

Krishna 的头像
Krishna1 个月前

Would it be ported to Mac too?

P 的头像
P1 个月前

That's very cool and very useful

Paul-Simon 的头像
Paul-Simon1 个月前

moving cold experts to cpu while keeping hot ones on gpu is the kind of practical hack that actually democratizes access.

Jan Koch 的头像
Jan Koch1 个月前

Just gave this to Hermes, let’s see what it thinks

Shane 的头像
Shane1 个月前

@grok is this deceptive? He claims one GPU then claims you need 4 GPU.

homuraakemifan 的头像
homuraakemifan1 个月前

Oh yeah finally someone turned MegaTrain into a Github repo 🙌🙌🙌🙌

Saman Ahmed 的头像
Saman Ahmed1 个月前

I've noticed efficiency tricks are becoming just as exciting as bigger models. My take making powerful AI easier to run changes who gets to experiment.

Nahid 的头像
Nahid1 个月前

28x speedup is wild for a single gpu setup

Glyph 的头像
Glyph1 个月前

So, they basically turned a massive hardware spend into a clever software trick. It's just optimizing where the actual heavy lifting happens.

neeraj 的头像
neeraj1 个月前

Bro I built this check my github I am working on same since 3 weeks 😭😭😭😭

Greg Janik 的头像
Greg Janik1 个月前

h100 racks are more expensive than b300s? lmao

Neanderthal Coder 的头像
Neanderthal Coder1 个月前

So I can run Kimi k3 on my Rpi5 cluster (cough, 2).

相关视频

Deepseek V4 Flash 0731 (Q2) - 12 tokens/sec - Single RTX 4090 - 650+ tokens/sec prefill - 250k context - no kv cache quantization! DeepSeek just dropped the official V4 Flash 0731 two days ago with a massive agent capabilities upgrade. The official benchmarks are literally crushing their own V4-Pro-Preview on agentic tasks like Terminal Bench 2.1 and DeepSWE. Unsloth AI said they couldn't wait to bring it to local devices, and they delivered. If you thought my 118B Poolside Laguna S 2.1 MoE run last week on a single GPU was wild, hold onto your hardware. I just successfully ran Unsloth’s brand new 91GB DeepSeek-V4-Flash-0731 (UD-IQ2_M) GGUF entirely locally. And I pushed it to a mind-bending 250,000 context window. The VRAM ceiling is an illusion if you know how to optimize llama.cpp. Here are the benchmarks and the cheat codes to run a local frontier class model yourself. For the hardware and setup, I used a single NVIDIA RTX 4090 (24GB VRAM) hooked up via a PCIe 4 bus, running Ubuntu 22.04 LTS and CUDA 13.0. You don't need a massive enterprise server for this, if you have more than 80 GB of standard DDR4 RAM and a 24GB card like an RTX 3090 or 4090, you can run this exact stack yourself. All benchmarks were run using a massive 28k token prompt to truly stress test the prefill limits. no kv cache quantization THE BENCHMARKS (Scaling Context): # 80k Context (Baseline: -b 2048 -ub 2048): Prefill: 465.43 t/s | Decode: 13.00 t/s | VRAM: 22.87 GB # 80k Context (Optimized: -b 4096 -ub 4096): Prefill: 643.15 t/s | Decode: 12.20 t/s | VRAM: 23.00 GB (Notice how doubling the batch flags spiked my prefill throughput by nearly 200 t/s with almost zero VRAM penalty) # 180k Context (-b 4096 -ub 4096): Prefill: 629.18 t/s | Decode: 11.92 t/s | VRAM: 23.40 GB # 250k Context MAXIMUM (-b 4096 -ub 4096): Prefill: 619.02 t/s | Decode: 11.54 t/s | VRAM: 23.40 GB # THE SECRET SAUCE (Why this works): Unsloth’s UD-IQ2_M quant is ~91GB across 3 files. Since I only have 24GB of VRAM, the PCIe 4 bus and system RAM have to do the heavy lifting. The magic bullet is the --no-mmap flag. By completely bypassing OS disk paging, I forced llama.cpp to load the massive model weights directly into the system RAM upfront. Combined with Flash Attention (-fa on) and exactly 12 CPU threads (--threads 12), I maintained an incredibly stable 11.5+ tokens/sec decode speed even at a quarter million token context. # THE EXACT COMMAND: ./build/bin/llama-server -m /workspace/models/DeepSeek-V4-Flash-0731-UD-IQ2_M-00001-of-00003.gguf -c 250000 -fa on --port 8080 --threads 12 -b 4096 -ub 4096 --no-mmap -v Local conversational and agentic coding AI is fully here. You don’t need an API or an H100 cluster. Qwen 3.8 27b drops next week making the 24GB VRAM tier even more worthwhile. What does your current local AI rig look like, and what's the craziest model you've managed to squeeze into it? Official huggingface GGUF links from Unsloth and performance graphs are dropped in the replies below!

Alok

46,100 次观看 • 1 个月前

UC Berkeley just open-sourced FreeToken. (2–4x faster local LLM inference than Ollama) the results are wild: - Qwen3.6-35B on an 8GB GPU at 39.3 tokens/s - DeepSeek-V4-Flash 284B on a 32GB GPU at 22 tokens/s - GLM-5.2 753B on a 96GB GPU at 14.9 tokens/s a 35B model at 16-bit precision needs about 70GB just for its weights. even at 4 bits it is close to 18GB, and FreeToken serves it on an 8GB GPU. let me explain how: all three models mentioned above are Mixture-of-Experts, and that is what FreeToken takes advantage of. each layer holds hundreds of separate experts plus a small router that picks a few of them per token. Qwen3.6-35B activates roughly 3B of its 35B parameters per token. DeepSeek-V4-Flash picks 6 of 256 experts per layer, so 13B of its 284B run at a time. so compute was never the bottleneck. the weights a single step touches fit comfortably on a consumer GPU. every expert the router might pick still has to exist somewhere. they sit in system RAM, and the GPU keeps a cache of the ones the model has been using recently. so everything comes down to what happens when the router picks an expert that is not on the GPU. there are two ways to serve that miss: 1. copy it over PCIe and run it on the GPU 2. run it on the CPU, where it already lives both read from the same system memory, so they compete for one pool of bandwidth instead of adding to each other. existing engines pick one option and freeze it when the model loads. but routing changes on every token, so a fixed choice misses most of what the model asks for. FreeToken measures both bandwidths on your machine and splits each step's misses between the two paths in proportion. the GPU and CPU results then merge exactly, with no approximation. two machines with the same GPU can end up wanting opposite strategies, which I did not expect. a 5090 in a gaming desktop should push nearly everything over PCIe, while an 8GB laptop is better off computing most misses on the CPU. none of that is readable off a spec sheet, so the engine profiles it once per machine. the second half of the design is about agents. coding agents constantly rewrite their own history, and every edit normally forces thousands of tokens back through prefill. FreeToken saves its checkpoints at the exact boundaries agent frameworks cut on, so it only reprocesses the new part. its slowest first token stays under 44 seconds, while llama.cpp peaks at 232 and KTransformers at 946. it serves the OpenAI and Anthropic APIs under Apache 2.0, so Claude Code and Codex can point at it directly. releasing weights publicly decides who can download a model, not who can afford to run one. frontier open models keep shipping, and running them still assumes a rented cluster. meanwhile there are over a hundred million consumer machines with discrete GPUs sitting mostly idle. closing that gap was never a hardware problem, and work like this is what turns open weights into something you can actually use. paper: repo: almost every idea in this post, from why memory bandwidth decides the outcome to why moving weights costs more than computing on them, comes straight out of how a GPU is built. I wrote a detailed primer on that. the article is quoted below.

Akshay 🚀

341,499 次观看 • 22 天前