mirror of
https://github.com/Niko1221/Strata.git
synced 2026-11-07 14:21:06 -10:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Niko1221
|
6abee7f397 | ||
|
Niko1221
|
868dc724d6 | ||
|
Niko1221
|
f1b35531c3 | ||
|
Niko1221
|
20351c6030 | ||
|
Niko1221
|
bbba5bf576 | ||
|
pete
|
5f563ce3a3 | ||
|
Niko1221
|
6c431c60cc | ||
|
Niko1221
|
822a5c783f | ||
|
Niko1221
|
0d721cf87b | ||
|
Niko1221andcode-martin
|
40542e8bb3 | ||
|
code-martin
|
e8b75ff2f6 | ||
|
code-martin
|
7f21e2b401 | ||
|
Niko1221
|
bbe8944ed3 | ||
|
Niko1221
|
54adac29a4 | ||
|
Niko1221
|
e5eb7b2ae7 | ||
|
Niko1221
|
8f279d82a0 | ||
|
Niko1221
|
0616dfb74e | ||
|
Jakub Luwierski
|
b819fe6934 | ||
|
Jakub Luwierski
|
e3e1493df4 | ||
|
Jakub Luwierski
|
4703da4363 | ||
|
Jakub Luwierski
|
9e6e5b7a1a | ||
|
Jakub Luwierski
|
2e9acd3d8b | ||
|
Jakub Luwierski
|
b7d73e1b32 | ||
|
Jakub Luwierski
|
8f3c21dc02 | ||
|
Jakub Luwierski
|
90546d7428 | ||
|
Jakub Luwierski
|
7546c36d9d | ||
|
Jakub Luwierski
|
dea4f4f2b5 | ||
|
btechnet
|
656a835682 | ||
|
Niko1221
|
55e2fb8576 | ||
|
Niko1221
|
59b0696208 | ||
|
Niko1221
|
0223d32663 | ||
|
Niko1221
|
d0017a7c58 | ||
|
Niko1221
|
0c2e63e930 | ||
|
Niko1221
|
888751a0e1 | ||
|
Niko1221
|
af1c91f245 | ||
|
Niko1221
|
14b22c51c1 | ||
|
Vistawizard
|
be028948f4 | ||
|
Mirtraxxx
|
470b3d7c21 | ||
|
Mirtraxxx
|
be0e0c94e3 | ||
|
Mirtraxxx
|
42810ee8bb | ||
|
btechnet
|
0f8b5d4938 | ||
|
Niko1221
|
07b4a6263a | ||
|
Niko1221
|
e550970773 | ||
|
Niko1221
|
6801c77ff6 |
No files matched your search
@@ -46,3 +46,4 @@ build-vision.bat
|
||||
/dist/
|
||||
*.done
|
||||
/third_party/*.zip
|
||||
|
||||
+24
-2
@@ -177,7 +177,10 @@ if(STRATA_ENABLE_CUDA)
|
||||
src/kernels/cuda/native_qsa_score.cu
|
||||
src/kernels/cuda/ple.cu
|
||||
src/kernels/cuda/kv_q8.cu
|
||||
src/kernels/cuda/kv_stream.cu
|
||||
src/kernels/cuda/kv_q4.cu
|
||||
src/kernels/cuda/fused_gr.cu
|
||||
src/kernels/cuda/cvec.cu
|
||||
src/kernels/cuda/qsa_decode_attn.cu
|
||||
src/kernels/cuda/fused_gdn.cu
|
||||
src/kernels/cuda/dequant_bf16.cu
|
||||
@@ -250,7 +253,7 @@ if(STRATA_ENABLE_CUDA)
|
||||
|
||||
add_executable(strata src/program/generate.cpp)
|
||||
target_include_directories(strata PRIVATE ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
|
||||
target_link_libraries(strata PRIVATE strata_engine strata_prefill CUDA::cudart)
|
||||
target_link_libraries(strata PRIVATE strata_engine strata_prefill strata_spec CUDA::cudart)
|
||||
|
||||
add_executable(dequant_s2_parity src/kernels/dequant_s2_parity.cpp)
|
||||
# The tests are HOST C++ files that call cudaMalloc/cudaMemcpy themselves, so they need the toolkit headers
|
||||
@@ -356,6 +359,22 @@ if(STRATA_ENABLE_CUDA)
|
||||
target_link_libraries(kv_q8_parity PRIVATE strata_kernels CUDA::cudart)
|
||||
add_test(NAME kv_q8_parity COMMAND kv_q8_parity)
|
||||
|
||||
# KV streaming (docs/kv-streaming-design.md): streamed vs resident attention, bitwise (GPU, synthetic, no model).
|
||||
add_executable(kv_stream_parity src/kernels/kv_stream_parity.cpp)
|
||||
target_include_directories(kv_stream_parity PRIVATE ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
|
||||
target_link_libraries(kv_stream_parity PRIVATE strata_kernels CUDA::cudart)
|
||||
add_test(NAME kv_stream_parity COMMAND kv_stream_parity)
|
||||
|
||||
# PR #21: Q4_0 KV with Walsh-Hadamard rotation vs a host reference (GPU, synthetic, no model).
|
||||
add_executable(kv_q4_parity src/kernels/kv_q4_parity.cpp)
|
||||
target_include_directories(kv_q4_parity PRIVATE ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
|
||||
target_link_libraries(kv_q4_parity PRIVATE strata_kernels CUDA::cudart)
|
||||
add_test(NAME kv_q4_parity COMMAND kv_q4_parity)
|
||||
add_executable(cvec_parity src/kernels/cvec_parity.cpp)
|
||||
target_include_directories(cvec_parity PRIVATE ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
|
||||
target_link_libraries(cvec_parity PRIVATE strata_kernels CUDA::cudart)
|
||||
add_test(NAME cvec_parity COMMAND cvec_parity)
|
||||
|
||||
# Plan v0.3 P3: native MMVQ for 1..8 tokens (bitwise selftest + --bench timing); synthetic data, no model.
|
||||
if(STRATA_BUILD_TESTS)
|
||||
add_executable(native_mmvq_multi bench/micro/native_mmvq_multi.cpp)
|
||||
@@ -417,7 +436,7 @@ endif()
|
||||
# worse opt-out. `cpu_require_expert_support()` therefore refuses at startup on a CPU without the
|
||||
# features, and the fallback exists for tests, exactly as P2.S3 specifies.
|
||||
# Plan v0.3 P6: speculation components that need no GPU.
|
||||
add_library(strata_spec STATIC src/spec/suffix_drafter.cpp src/spec/controller.cpp)
|
||||
add_library(strata_spec STATIC src/spec/suffix_drafter.cpp src/spec/controller.cpp src/spec/draft_policy.cpp)
|
||||
target_include_directories(strata_spec PUBLIC include)
|
||||
if(STRATA_BUILD_TESTS)
|
||||
add_executable(suffix_drafter_test src/spec/suffix_drafter_test.cpp)
|
||||
@@ -426,6 +445,9 @@ if(STRATA_BUILD_TESTS)
|
||||
add_executable(controller_test src/spec/controller_test.cpp)
|
||||
target_link_libraries(controller_test PRIVATE strata_spec)
|
||||
add_test(NAME controller_test COMMAND controller_test)
|
||||
add_executable(draft_policy_test src/spec/draft_policy_test.cpp)
|
||||
target_link_libraries(draft_policy_test PRIVATE strata_spec)
|
||||
add_test(NAME draft_policy_test COMMAND draft_policy_test)
|
||||
endif()
|
||||
|
||||
add_library(strata_kernels_cpu STATIC src/kernels/cpu/expert.cpp src/kernels/cpu/pool.cpp
|
||||
|
||||
@@ -1,313 +1,146 @@
|
||||
<h1 align="center">Qwen3.8-Flash-Next (125B MoE) on a 12-24 GB NVIDIA GPU + 64 GB RAM: one-click install for Windows / Linux</h1>
|
||||
<h1 align="center">Strata</h1>
|
||||
|
||||
<p align="center"><b>Strata</b>: an inference engine built for exactly one model and exactly this kind of PC</p>
|
||||
<p align="center"><b>Run a 125-billion-parameter AI model on a normal gaming PC</b><br>
|
||||
one NVIDIA card (12-24 GB) + 64 GB of RAM · Windows or Linux · one click to install</p>
|
||||
|
||||
A 125-billion-parameter mixture-of-experts model (6B active per token) on a **normal gaming PC**: one NVIDIA card with
|
||||
12-24 GB of VRAM, 64 GB of RAM and a desktop CPU. Strata keeps the always-used part of the model on the GPU, all 24,576
|
||||
experts in RAM, computes the experts the GPU does not hold on the CPU at the same time, and checks several tokens per
|
||||
pass with the model's own multi-token-prediction (MTP) layer. The text it produces is identical to plain greedy decoding.
|
||||
Strata runs **[Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)** - a large, smart AI model that
|
||||
normally needs a server - on your own PC. It writes its answers at **60-95 tokens per second** (a token is about ¾
|
||||
of a word): faster than you can read.
|
||||
|
||||
It serves an **OpenAI-** and **Anthropic-compatible API on localhost**, so any chat app, coding agent or script that
|
||||
talks to those APIs can use it. Optionally it also **reads images** (screenshots, photos, scanned pages) with the
|
||||
model's own vision encoder.
|
||||
- **Private:** everything runs on your PC. Nothing is sent anywhere.
|
||||
- **Works with your apps:** chat apps, coding agents and scripts that speak the OpenAI or Anthropic API just work.
|
||||
- **Sees pictures** too, if you want (screenshots, photos, scanned pages).
|
||||
- **Free and open source.**
|
||||
|
||||
> **Jump to:** [Speed](#speed-measured) · [Other GPUs](#other-gpus-estimated) · [Which model?](#which-model) ·
|
||||
> [Windows](#windows) · [Linux](#linux) · [Using it](#using-it) · [Images](#images-vision) ·
|
||||
> [Troubleshooting](#troubleshooting) · [How it works](#how-it-works)
|
||||
> **Jump to:** [Is my PC enough?](#is-my-pc-enough) · [Install](#install-3-steps) · [How fast?](#how-fast-is-it) ·
|
||||
> [Which model?](#which-model-should-i-pick) · [Using it](#using-it) · [Problems?](#something-went-wrong) ·
|
||||
> [How it works](#how-does-it-work) · [All the details](docs/DETAILS.md)
|
||||
|
||||
---
|
||||
|
||||
## Speed (measured)
|
||||
## Is my PC enough?
|
||||
|
||||
RTX 5070 **12 GB**, Ryzen 5 7600 (6 cores), 64 GB DDR5-5200, Windows. One code-agent prompt per length, 256 generated
|
||||
tokens, MTP speculative decoding on. "262K" is the model's full context window (a 259,943-token prompt).
|
||||
|
||||
### Prompt processing (tokens/s)
|
||||
|
||||
| Model | 1K | 4K | 32K | 64K | 128K | 262K |
|
||||
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
|
||||
| **Q2_0** | 389 | 539 | 571 | 561 | 543 | 496 |
|
||||
| **IQ2_XS** | 332 | 463 | 495 | 486 | 472 | 437 |
|
||||
| **IQ3_XXS** | 285 | 410 | 435 | 427 | 414 | - |
|
||||
|
||||
### Output (tokens/s)
|
||||
|
||||
| Model | 1K | 4K | 32K | 64K | 128K | 262K |
|
||||
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
|
||||
| **Q2_0** | 88.7 | 94.6 | 87.5 | 76.4 | 65.1 | 56.3 |
|
||||
| **IQ2_XS** | 82.0 | 78.0 | 65.3 | 63.7 | 52.0 | 48.0 |
|
||||
| **IQ3_XXS** | 64.6 | 65.6 | 57.3 | 54.4 | 44.8 | - |
|
||||
|
||||
IQ3_XXS at 262K is not measured: with its 43 GB of experts, a 260K-token context brings a 64 GB PC to its memory
|
||||
limit. Use up to 128K with IQ3_XXS on 64 GB.
|
||||
|
||||
Time to first token is prompt length / prompt speed: about 7 s at 4K, 55 s at 32K, 4 minutes at 128K and 9 minutes at
|
||||
262K. The raw numbers: `bench/results/`. The [paper](docs/paper/Strata-Paper.pdf) explains every number.
|
||||
|
||||
## Other GPUs (estimated)
|
||||
|
||||
Not measured - estimated from the runs above (same CPU and 64 GB RAM): the GPU part scaled by memory bandwidth, the CPU
|
||||
part by how many more experts the card's VRAM holds. Treat as **±20%**. Numbers are *prompt / output* tokens/s.
|
||||
|
||||
| GPU | Model | 1K | 4K | 32K | 64K | 128K | 262K |
|
||||
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
|
||||
| RTX 5060 Ti 16GB | Q2_0 | ~341 / ~80 | ~472 / ~87 | ~501 / ~81 | ~492 / ~72 | ~476 / ~62 | ~435 / ~53 |
|
||||
| | IQ2_XS | ~291 / ~80 | ~406 / ~77 | ~434 / ~63 | ~426 / ~62 | ~413 / ~51 | ~383 / ~47 |
|
||||
| | IQ3_XXS | ~249 / ~66 | ~359 / ~65 | ~381 / ~56 | ~374 / ~54 | ~363 / ~45 | - |
|
||||
| RTX 3090 24GB | Q2_0 | ~355 / ~128 | ~491 / ~140 | ~521 / ~130 | ~512 / ~115 | ~495 / ~100 | ~453 / ~85 |
|
||||
| | IQ2_XS | ~303 / ~131 | ~422 / ~128 | ~451 / ~103 | ~444 / ~102 | ~430 / ~85 | ~398 / ~78 |
|
||||
| | IQ3_XXS | ~260 / ~106 | ~374 / ~103 | ~396 / ~89 | ~390 / ~85 | ~378 / ~71 | - |
|
||||
|
||||
More VRAM matters more than a faster GPU: every extra GB holds ~700 more experts, and every expert on the GPU is one the
|
||||
CPU does not have to compute. A 3090's 24 GB takes most of the CPU work away.
|
||||
|
||||
## Which model?
|
||||
|
||||
All three are [ISTA-DASLab's GSQ-RCO quantizations](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF)
|
||||
of [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next).
|
||||
|
||||
| Model | Download | RAM it uses | Speed | Quality |
|
||||
| --- | ---: | ---: | --- | --- |
|
||||
| **Q2_0** | 66 GB | ~34 GB experts + ~6 GB | fastest | good |
|
||||
| **IQ2_XS** | 68 GB | ~36 GB experts + ~6 GB | close to Q2_0 | a bit better |
|
||||
| **IQ3_XXS** | 76 GB | ~43 GB experts + ~6 GB | slower (more CPU work) | best |
|
||||
|
||||
With 64 GB of RAM all three fit (close the browser for IQ3_XXS, and keep its context at 128K or less). With 48 GB only Q2_0 / IQ2_XS may fit. 32 GB is not enough.
|
||||
|
||||
## Before you start
|
||||
|
||||
You need **only an NVIDIA driver** (version 580 or newer; update it with the NVIDIA App or from
|
||||
[nvidia.com/drivers](https://www.nvidia.com/drivers)). Everything else is installed for you the first time.
|
||||
|
||||
| | |
|
||||
| You need | |
|
||||
| --- | --- |
|
||||
| GPU | NVIDIA **RTX 30, 40 or 50 series**, **12 GB VRAM or more** (8 GB runs, slowly). Measured on an RTX 5070; RTX 30/40 are untested. |
|
||||
| RAM | **64 GB** recommended (see the table above). |
|
||||
| CPU | x86-64 with AVX2 (any Intel/AMD desktop CPU from the last ~8 years). AVX-512 (Ryzen 7000/9000) is a bit faster. |
|
||||
| Disk | ~70-80 GB free for the model, ~6 GB for the MTP layer (+1 GB with images). **Q2_0 on an AVX-512 CPU** also writes a one-time ~40 GB copy of its experts for the fast CPU kernel. An NVMe SSD is strongly recommended. |
|
||||
| OS | Windows 10/11, or Linux (Ubuntu 22.04/24.04 get everything installed automatically). |
|
||||
| **Graphics card** | NVIDIA RTX 30, 40 or 50 series with **12 GB of VRAM or more** |
|
||||
| **Memory (RAM)** | **64 GB** |
|
||||
| **Free disk space** | ~80 GB (an SSD makes the first start much faster) |
|
||||
| **System** | Windows 10/11, or Linux |
|
||||
|
||||
What the first start installs, all inside this folder (`.venv/`, `engine/`, `third_party/`, `models/`, `packs/`, `mtp/`):
|
||||
Python 3.12 if you have none (for your user account, no admin), a private Python environment, NVIDIA's CUDA libraries
|
||||
(from pip, ~0.4 GB), the ready-made Strata engine for RTX 30/40/50, the model and the MTP draft layer. If no
|
||||
ready-made engine fits your PC, it offers to install the build tools (Visual Studio Build Tools + CUDA Toolkit on
|
||||
Windows, `build-essential` + CUDA on Ubuntu) and compiles the engine for your GPU (asks first; 20-40 minutes once).
|
||||
That's it. The only thing you install yourself is a current **NVIDIA driver**
|
||||
([nvidia.com/drivers](https://www.nvidia.com/drivers) or the NVIDIA App). Everything else - Python, the engine, the
|
||||
model - is set up for you.
|
||||
|
||||
---
|
||||
## Install (3 steps)
|
||||
|
||||
## Windows
|
||||
**Windows**
|
||||
|
||||
### Double-click `START-HERE.bat`
|
||||
1. [Download this project](https://github.com/Niko1221/Strata/archive/refs/heads/main.zip) and unzip it (or `git clone` it).
|
||||
2. Double-click **`START-HERE.bat`**.
|
||||
3. Answer 4 questions - or just press Enter each time for the recommended choice:
|
||||
- **Which model?** The original, or Swift 1.5 (a version that thinks shorter and answers sooner)
|
||||
- **Which size?** Q2_0, IQ2_XS, IQ3_XXS or IQ3_S - see [which model](#which-model-should-i-pick)
|
||||
- **How much context?** How much text it can keep in mind at once (it suggests one for your card)
|
||||
- **Images?** Whether it should also read pictures
|
||||
|
||||
**The first time** it asks three questions and does the rest:
|
||||
Then it downloads everything (the model is ~70 GB, so the first time takes a while - you can stop and it picks up
|
||||
where it left off) and **starts the model**. Your browser opens the Strata app at `http://127.0.0.1:8080`.
|
||||
|
||||
1. **Which model?** Q2_0, IQ2_XS or IQ3_XXS (it recommends one for your RAM).
|
||||
2. **How much context?** 8K to 256K tokens (it recommends one for your VRAM).
|
||||
3. **Images?** yes / no (see [Images](#images-vision)).
|
||||
**Next time**, just double-click `START-HERE.bat` again: it starts right away, nothing is downloaded twice. Close its
|
||||
window to stop the model.
|
||||
|
||||
Then it downloads and prepares everything (the model is 66-76 GB, so the first start takes a while; an interrupted
|
||||
download continues where it stopped) and **starts the model**: your browser opens `http://127.0.0.1:8080`, a small
|
||||
page that shows it is running and lets you chat. The API is at `http://127.0.0.1:8080/v1` for your apps.
|
||||
**Linux:** run `./setup.sh` - same questions, same result.
|
||||
|
||||
**Every time after that**, `START-HERE.bat` just starts the model (30-90 s to load 34-43 GB into RAM). Nothing is
|
||||
downloaded again. Closing the window stops the model.
|
||||
## How fast is it?
|
||||
|
||||
```
|
||||
START-HERE.bat --setup install another model, or change context / images
|
||||
START-HERE.bat --model IQ2_XS --context 32768 --vision yes --yes no questions
|
||||
START-HERE.bat --gguf-dir D:\models\IQ2_XS use GGUF files you already have
|
||||
START-HERE.bat --port 8081 another port
|
||||
```
|
||||
Measured on an RTX 5070 (12 GB), a Ryzen 5 7600 and 64 GB of RAM:
|
||||
|
||||
With more than one model installed, it asks which one to start. `run-<model>.bat` starts a model directly.
|
||||
| Size | Writes answers (short chat) | Writes answers (128K context) | Reads your prompt |
|
||||
| --- | ---: | ---: | ---: |
|
||||
| **Q2_0** | 95 tokens/s | 65 tokens/s | 539 tokens/s |
|
||||
| **IQ2_XS** | 78 tokens/s | 52 tokens/s | 463 tokens/s |
|
||||
| **IQ3_XXS** | 66 tokens/s | 45 tokens/s | 410 tokens/s |
|
||||
| **IQ3_S** | 54 tokens/s | 42 tokens/s | 374 tokens/s |
|
||||
|
||||
### Chat in the terminal (optional)
|
||||
- **Writes answers** = how fast the reply appears (tokens per second).
|
||||
- **Reads your prompt** = how fast it takes in what you send (long documents, code, chat history).
|
||||
|
||||
```
|
||||
.venv\Scripts\python chat.py
|
||||
```
|
||||
A card with more VRAM is faster, because more of the model fits on the GPU: an RTX 3090 (24 GB) should do roughly
|
||||
100-140 tokens per second. All measurements, long-context numbers and estimates for other cards are in the
|
||||
[details](docs/DETAILS.md#speed-measured).
|
||||
|
||||
---
|
||||
## Which model should I pick?
|
||||
|
||||
## Linux
|
||||
**The size** (the same model, compressed more or less):
|
||||
|
||||
```bash
|
||||
./setup.sh
|
||||
```
|
||||
| Size | Download | Speed | Quality | Pick it if... |
|
||||
| --- | ---: | --- | --- | --- |
|
||||
| **Q2_0** | 66 GB | fastest | good | you want speed |
|
||||
| **IQ2_XS** | 68 GB | fast | better | you want a good all-rounder (**recommended**) |
|
||||
| **IQ3_XXS** | 76 GB | slower | great | you want better answers (uses 43 GB of your 64 GB RAM) |
|
||||
| **IQ3_S** | 84 GB | slowest | best: matches the full model on the published tests | you want the very best answers (original model only; uses 50 GB of your 64 GB RAM, so close other big programs) |
|
||||
|
||||
The same three questions, the same automatic install (it uses `sudo apt` for Python and, only if it has to compile,
|
||||
for the build tools), and the same start: `http://127.0.0.1:8080`. Later runs of `./setup.sh` (or `./run-<model>.sh`)
|
||||
start the model directly. Options as on Windows (`./setup.sh --setup`, `--model Q2_0 --yes`, `--gguf-dir /data/Q2_0`).
|
||||
Terminal chat: `.venv/bin/python chat.py`.
|
||||
**The version:**
|
||||
|
||||
---
|
||||
- **Qwen3.8-Flash-Next** - the original.
|
||||
- **[Swift 1.5](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF)** - a fine-tune by UkisAI
|
||||
that thinks much shorter before answering, so you get the answer sooner, with about the same quality. Same speed per
|
||||
token. Its own license applies (see its page).
|
||||
|
||||
Not sure? Take **IQ2_XS**. You can add another one later with `START-HERE.bat --setup`.
|
||||
|
||||
## Using it
|
||||
|
||||
The server listens on `http://127.0.0.1:8080` (change with `--port` in setup, or edit the run script).
|
||||
- **In the browser:** `http://127.0.0.1:8080` - the Strata app (it opens by itself when the model starts): **Chat**, a
|
||||
live **Monitor** of the model and your GPU/CPU/RAM, and **About** with the settings and addresses.
|
||||
- **Chat in the terminal:** `.venv\Scripts\python chat.py`
|
||||
- **Your apps and coding agents:** add it as an "OpenAI-compatible" provider with base URL
|
||||
**`http://127.0.0.1:8080/v1`**, any API key and any model name. Apps that use Anthropic's API: `http://127.0.0.1:8080/v1/messages`.
|
||||
- **Thinking:** the model thinks before it answers. Choose **off, low, medium or high** - in the chat page menu, with
|
||||
`/think low` in `chat.py`, or with your app's "reasoning effort" setting. Off is fastest; high is best for hard questions.
|
||||
- **Pictures:** in the chat page click **Picture**; in `chat.py` type `/image <path>`; in apps just attach them.
|
||||
- **From your phone or another PC:** `START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>`, then open the
|
||||
address the server window prints; see the [details](docs/DETAILS.md#using-it).
|
||||
- **Experimental speed projection (off by default):** an experimental control vector that setup can turn on; it
|
||||
changes how the model answers - read [what it does](docs/DETAILS.md#experimental-speed-projection-experimental-off-by-default) first.
|
||||
|
||||
| API | Endpoint |
|
||||
**Good to know:** it answers one request at a time. The first message of a chat is read in full (about 1 minute per
|
||||
30,000 tokens); after that it keeps the conversation and reads only what is new, so follow-ups start in seconds.
|
||||
|
||||
## Something went wrong?
|
||||
|
||||
| What you see | What to do |
|
||||
| --- | --- |
|
||||
| OpenAI Chat Completions (stream and non-stream, tools) | `POST /v1/chat/completions` |
|
||||
| Anthropic Messages (stream and non-stream, tools) | `POST /v1/messages` |
|
||||
| Model list / health | `GET /v1/models`, `GET /health` |
|
||||
| `the NVIDIA driver is too old` | Update the driver (NVIDIA App or nvidia.com/drivers), restart the PC, run `START-HERE.bat` again. |
|
||||
| It stopped during download or setup | Run `START-HERE.bat` again - it continues where it stopped. |
|
||||
| `port 8080 is already in use` | Strata is already running - look for its window. |
|
||||
| The first start takes minutes | Normal: it loads 35-43 GB into RAM. The next start is faster. |
|
||||
| Slow, and the disk light is busy | Not enough free RAM: close other programs (browsers use a lot), or pick Q2_0 / IQ2_XS. |
|
||||
| "prompt exceeds the context" | The conversation is longer than the context you chose: run `START-HERE.bat --setup` and pick more. |
|
||||
|
||||
```bash
|
||||
curl http://127.0.0.1:8080/v1/chat/completions -H "Content-Type: application/json" -d '{
|
||||
"model": "strata", "messages": [{"role": "user", "content": "Write a haiku about GPUs."}], "max_tokens": 512 }'
|
||||
```
|
||||
More in the [full troubleshooting table](docs/DETAILS.md#troubleshooting). Still stuck? Open an issue and attach
|
||||
`strata-<model>.log` from this folder.
|
||||
|
||||
```python
|
||||
from openai import OpenAI
|
||||
client = OpenAI(base_url="http://127.0.0.1:8080/v1", api_key="none")
|
||||
r = client.chat.completions.create(model="strata", messages=[{"role": "user", "content": "Hello!"}])
|
||||
print(r.choices[0].message.content)
|
||||
```
|
||||
## How does it work?
|
||||
|
||||
- **Thinking levels: none, low, medium, high.** The model thinks before it answers (streamed as
|
||||
`reasoning_content`, Anthropic: `thinking` blocks). Choose how much per request - in the chat page (the "Thinking"
|
||||
menu), in `chat.py` (`/think low`), or over the API:
|
||||
A model this big doesn't fit on a gaming graphics card. Strata splits the work between the parts of your PC:
|
||||
|
||||
| API | how |
|
||||
| --- | --- |
|
||||
| OpenAI | `"reasoning_effort": "none" \| "low" \| "medium" \| "high"` (also `"reasoning": {"effort": ...}`, or `"chat_template_kwargs": {"enable_thinking": false}`) |
|
||||
| Anthropic | `"output_config": {"effort": "low" \| "medium" \| "high"}`, `"thinking": {"type": "disabled"}`, or `"thinking": {"type": "enabled", "budget_tokens": N}` (under 2K = low, under 8K = medium, more = high) |
|
||||
<p align="center"><img src="docs/paper/tiers.svg" width="700" alt="how Strata splits the model between GPU, RAM and SSD"></p>
|
||||
|
||||
Without a setting the model uses its own default, **high**. `none` answers at once (fastest); `low` keeps the thinking
|
||||
short. The levels are instructions the model was trained with, not a hard token limit: on easy questions all three
|
||||
think briefly, on hard ones `high` thinks longest and is most accurate.
|
||||
- **Chat apps.** Any app with an "OpenAI-compatible" provider works: base URL `http://127.0.0.1:8080/v1`, any API key.
|
||||
- **Context.** Chosen in setup (8K-262K). Requests longer than that are refused, never silently cut.
|
||||
- **From other devices / the internet.** The server listens on your PC only (`127.0.0.1`). To reach it from elsewhere,
|
||||
put a tunnel in front of it, for example [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/do-more-with-tunnels/trycloudflare/):
|
||||
`cloudflared tunnel --url http://127.0.0.1:8080`. **Set a key first**, or anyone with the link can use your PC:
|
||||
add `"api_key": "some-long-secret"` to `strata-<model>.json` (or set the `STRATA_API_KEY` environment variable);
|
||||
clients then send it as their API key.
|
||||
- **The GPU** runs the part of the model that is used for every word, plus the "experts" it needs most often.
|
||||
- **The RAM** holds all 24,576 experts, and **the CPU** computes the few the GPU doesn't have - at the same time as the GPU.
|
||||
- **The SSD** holds a big lookup table; the model reads a few rows of it per word.
|
||||
- **A small helper inside the model guesses the next words**, and Strata checks several guesses at once. That makes
|
||||
it 1.6-1.8x faster than going word by word - and the answer is exactly the same.
|
||||
|
||||
**Current limits (v1):** one request at a time; greedy decoding (temperature is ignored); every request processes its
|
||||
whole prompt again (no conversation cache yet, so long chats have a long time-to-first-token); images only when set up
|
||||
with them (below); no video.
|
||||
The full story is in the [paper](docs/paper/Strata-Paper.pdf) and the [details](docs/DETAILS.md).
|
||||
|
||||
---
|
||||
## Credits
|
||||
|
||||
## Images (vision)
|
||||
|
||||
The model has a vision encoder: [`mmproj-Qwen3.8-Flash-Next-BF16.gguf`](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF)
|
||||
(0.9 GB, a 27-layer ViT plus the projector into the language model). It is **optional**: say yes when the setup asks
|
||||
"Images?", or run it again with `--vision gpu` (or `--vision cpu`). The setup downloads the encoder, builds a small
|
||||
helper (`strata-vision`, from llama.cpp's `mtmd` library) and adds it to your start script. Nothing else changes.
|
||||
|
||||
| Encoder on | Time per picture | Cost |
|
||||
| --- | --- | --- |
|
||||
| **GPU** (recommended) | **0.1-0.5 s** (up to 1,024 image tokens) | ~1.4 GB of VRAM is kept free for it, so the expert cache is smaller: text output is a few % slower (table below) |
|
||||
| CPU | 10-30 s (pictures are scaled down to ~300 image tokens) | nothing on the GPU |
|
||||
|
||||
A picture becomes up to 1,024 tokens of the context (a 640x480 photo: 300). The same picture sent again, as chat apps
|
||||
do on every turn, is encoded only once.
|
||||
|
||||
### Sending a picture
|
||||
|
||||
**Terminal chat:** type `/image <path to a picture>`, press Enter, then type your question.
|
||||
|
||||
```
|
||||
you> /image C:\Users\me\Pictures\receipt.jpg
|
||||
(picture attached: receipt.jpg - now type your question)
|
||||
you> What is the total on this receipt?
|
||||
```
|
||||
|
||||
**OpenAI API** (an `image_url` part: a `data:` URL, an `http(s)://` URL or a local file path):
|
||||
|
||||
```python
|
||||
import base64
|
||||
from openai import OpenAI
|
||||
client = OpenAI(base_url="http://127.0.0.1:8080/v1", api_key="none")
|
||||
img = base64.b64encode(open("photo.jpg", "rb").read()).decode()
|
||||
r = client.chat.completions.create(model="strata", messages=[{"role": "user", "content": [
|
||||
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img}"}},
|
||||
{"type": "text", "text": "What is in this picture?"}]}])
|
||||
print(r.choices[0].message.content)
|
||||
```
|
||||
|
||||
**Anthropic API:** an `image` block with a `base64` (or `url`) source, as usual.
|
||||
|
||||
JPEG, PNG, BMP and GIF work (WebP does not). Chat apps with image upload work the same way.
|
||||
|
||||
### Speed with images on (4K context, measured)
|
||||
|
||||
| Model | Prompt tok/s, images off | Prompt tok/s, images on | Output tok/s, images off | Output tok/s, images on |
|
||||
| --- | ---: | ---: | ---: | ---: |
|
||||
| **Q2_0** | 541 | 531 | 90.7 | 86.9 |
|
||||
| **IQ2_XS** | 468 | 458 | 77.1 | 74.0 |
|
||||
| **IQ3_XXS** | 411 | 401 | 64.7 | 59.5 |
|
||||
|
||||
"Off" is the published setup; "on" runs with the encoder loaded on the GPU and its VRAM kept free, so ~1,000 fewer
|
||||
experts fit in VRAM and the CPU computes a few more per token: 2-8% slower. For text, turning images on changes
|
||||
nothing else (the output is bit-identical when the VRAM is the same).
|
||||
|
||||
A question about a picture (a 640x480 newspaper page = 300 image tokens, a 328-token prompt; the whole request, encoder
|
||||
on the GPU, measured through the API):
|
||||
|
||||
| Model | Answer ("MEN WALK ON MOON") | Picture encoded | Prompt | Output |
|
||||
| --- | ---: | ---: | ---: | ---: |
|
||||
| **Q2_0** | 1.9 s | ~0.1 s | 207 tok/s | 65-73 tok/s |
|
||||
| **IQ2_XS** | 2.3 s | ~0.1 s | 173 tok/s | 50-60 tok/s |
|
||||
| **IQ3_XXS** | 2.7 s | ~0.1 s | 144 tok/s | 41-50 tok/s |
|
||||
|
||||
(Short prompts run below the 4K prompt speed: a 2,048-token chunk is where the prompt path is efficient. Short answers
|
||||
run below the long-output speed: the first rounds have no draft yet.)
|
||||
|
||||
**How it works inside:** the encoder turns the picture into rows of the same width as the model's word embeddings;
|
||||
Strata puts them where the prompt has `<|image_pad|>` tokens and gives each one its 2-D position (row and column in the
|
||||
picture; the model uses interleaved M-RoPE). Answers match llama.cpp's multimodal implementation token for token on our
|
||||
test images.
|
||||
|
||||
---
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
| Symptom | What to do |
|
||||
| --- | --- |
|
||||
| `the NVIDIA driver is too old` | Update the driver (NVIDIA App or nvidia.com/drivers), restart, run `START-HERE.bat` again. |
|
||||
| Python or the build tools could not be installed | Install what it names (links are printed), then run it again. Everything already done is kept. |
|
||||
| `port 8080 is already in use` | Strata is already running (look for its window), or another program uses the port: `START-HERE.bat --port 8081`. |
|
||||
| `cudaHostRegister ... out of memory` in the log | Normal on Windows: the engine pins the experts in per-layer slices instead. Only a problem if the load then fails. |
|
||||
| The first start takes minutes | It is reading 34-43 GB into RAM; the second start is faster while the files are in the OS cache. |
|
||||
| Slow output, disk light busy | Not enough free RAM: close other programs, or choose Q2_0 / IQ2_XS. |
|
||||
| `prompt ... exceeds the context` | The request is longer than the context you chose: run setup again with a bigger `--context`. |
|
||||
| Slower than the tables | The monitor plugged into the GPU and other GPU programs take VRAM from the expert cache; RAM running below its rated speed (enable EXPO/XMP in the BIOS) slows the CPU half. |
|
||||
| `this server was started without the vision encoder` | The model was set up for text only: run setup again with `--vision gpu`. |
|
||||
| A picture is refused or `cannot read the image` | Use JPEG, PNG, BMP or GIF (not WebP). |
|
||||
| Pictures are slow (10-30 s) | The encoder runs on the CPU: run setup again with `--vision gpu` (needs ~1.4 GB of VRAM). |
|
||||
| Anything else | The engine log is `strata-<model>.log` in this folder. |
|
||||
|
||||
---
|
||||
|
||||
## How it works
|
||||
|
||||
<p align="center"><img src="docs/paper/tiers.svg" width="760" alt="memory tiers"></p>
|
||||
|
||||
- **GPU (VRAM):** attention and DeltaNet mixers, the gated-residual weights, routers, shared experts, output head, the MTP
|
||||
draft layer, the KV cache, and an **expert cache** that fills the rest of VRAM with the most-used experts (it adapts to
|
||||
the conversation while you chat).
|
||||
- **RAM:** all 24,576 experts, pinned. The CPU computes the experts that are not on the GPU **in place**, at the same time
|
||||
as the GPU works on the cached ones (AVX-512 / AVX2 kernels, ggml's for the i-quants).
|
||||
- **SSD:** the 28.8 GB n-gram table, read a few rows per token through the OS cache.
|
||||
- **Speculation:** the model's own MTP layer drafts up to 3 tokens; one pass over all 48 layers checks them. 2.4-3.2
|
||||
tokens per pass on average.
|
||||
- **Prompts** are processed in 2,048-token chunks with the experts streamed to the GPU over PCIe.
|
||||
|
||||
The full story, with measurements, bottlenecks and what comes next: **[docs/paper/Strata-Paper.pdf](docs/paper/Strata-Paper.pdf)**.
|
||||
|
||||
---
|
||||
|
||||
## Credits and licenses
|
||||
|
||||
- Model: [Qwen/Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next) by the Qwen team; quantizations:
|
||||
[ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF).
|
||||
Their licenses apply to the weights.
|
||||
- [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp) (MIT): the i-quant formats, the GPU dot products and
|
||||
dequantizers transcribed in `src/kernels/cuda/iq_kernels.cu`, the CPU backend linked for the i-quant experts, the
|
||||
`mtmd` library behind the image encoder (`tools/vision/`), and `gguf-py` used by the tools. See
|
||||
`third_party/ggml/LICENSE`.
|
||||
- Ideas from [Splash](https://github.com/incoai/splash), [ninfer](https://github.com/Neroued/ninfer) and
|
||||
[HyperQwen](https://github.com/syv-ai/HyperQwen); references in the paper.
|
||||
- Model: [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next) by the Qwen team; compressed versions by
|
||||
[ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF);
|
||||
[Swift 1.5](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF) by UkisAI. Their licenses apply
|
||||
to the model files.
|
||||
- Built with parts of [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp) (MIT). Ideas from
|
||||
[Splash](https://github.com/incoai/splash), [ninfer](https://github.com/Neroued/ninfer) and
|
||||
[HyperQwen](https://github.com/syv-ai/HyperQwen). More in the [details](docs/DETAILS.md#credits-and-licenses).
|
||||
@@ -0,0 +1,29 @@
|
||||
# 2026-09-27: expert cache on vs off (issue #23)
|
||||
|
||||
Question: the engine used to warn at start that "the GPU hit path is NOT CORRECT ... any OUTPUT from it is not". Does
|
||||
the expert cache make the output worse?
|
||||
|
||||
Method: teacher-forced. `strata --dump-logits` runs a text one token at a time and writes the logits at every
|
||||
position, so both runs see the same text and each position's next-token prediction can be compared:
|
||||
- cache off: no `--expert-cache`, every routed expert computed by the CPU pool;
|
||||
- cache on: `--expert-profile pack/profile-decode-8k.bin --expert-cache auto`, 5,130 of the most-used experts on the GPU.
|
||||
|
||||
Q2_0, RTX 5070, the first 512 or 1,024 tokens of three frozen prompts.
|
||||
|
||||
| Text | Same top-1 | Median KL | Perplexity off | Perplexity on | On - off (nats per token) |
|
||||
|---|---:|---:|---:|---:|---:|
|
||||
| Code agent (512) | 97.7% | 3.0e-04 | 2.672 | 2.630 | -0.016 +- 0.019 |
|
||||
| Long document (1,024) | 96.2% | 4.5e-03 | 29.844 | 29.843 | -0.000 +- 0.005 |
|
||||
| Chat (1,024) | 95.0% | 4.4e-03 | 18.380 | 18.301 | -0.004 +- 0.006 |
|
||||
| **All 2,557 tokens** | | | | | **-0.005 +- 0.005** |
|
||||
|
||||
Reading:
|
||||
- The cache changes which of two nearly equal candidates wins at 2-5% of positions. Most of the flips have a top-2
|
||||
margin under 0.5 logits (`logits-compare.txt`).
|
||||
- Neither side is more accurate: the perplexity of the actual text is the same, within 1 standard error.
|
||||
- A GPU expert and the CPU compute the same quantized expert with a different floating-point order. Both are an
|
||||
equally good approximation of the model.
|
||||
|
||||
The start-up warning dates from round 328, when the GPU hit path had a real fault (divergence from token 0). That fault
|
||||
was fixed long ago and is covered by `expert_parity`, `native_expert_parity` and the grouped kernels' tests. Since
|
||||
engine 0.1.8 the warning is replaced by one accurate line.
|
||||
@@ -0,0 +1,36 @@
|
||||
# 2026-09-27: the experimental-speed-projection control vector
|
||||
|
||||
The package's `Qwen3.8-Flash-Next-experimental-speed-projection.gguf` (47 unit directions of 2,560, one per layer),
|
||||
applied as `--control-vector-scaled FILE:1.0 --control-vector-layer-range 4 44 --cvec-mode project --cvec-dir
|
||||
per-layer`: after layers 4-44, every hyper-connection stream `h -= (h . v) v`. The package describes it as a
|
||||
refusal-direction projection. Q2_0, RTX 5070, fixed experts (`--expert-cache 4000 --pcie-frac 0 --adapt-swaps 0`).
|
||||
|
||||
## Kernel (`cvec_parity`)
|
||||
|
||||
Project and add against a double-precision reference (max error 5e-7); with the switch off, the kernel's pending
|
||||
residual write is bitwise the fused hyper-connection read's own, so a loaded-but-off vector is the stock engine.
|
||||
|
||||
## Teacher-forced, stock vs projection (`esp_kl.py`, per-token path)
|
||||
|
||||
| Text | Tokens | Same top-1 | Mean KL | p99 KL | Perplexity stock | With the vector |
|
||||
|---|---:|---:|---:|---:|---:|---:|
|
||||
| Code | 511 | 92.8% | 0.098 | 1.69 | 2.594 | 2.982 |
|
||||
| Document | 1,023 | 89.8% | 0.058 | 0.84 | 30.299 | 30.984 |
|
||||
| Chat | 1,023 | 89.6% | 0.050 | 0.33 | 18.409 | 18.485 |
|
||||
| **All** | 2,557 | | **0.063** (max 4.10) | 1.00 | | |
|
||||
|
||||
The package reports a mean KL of 0.186 on its own neutral text with UD-Q2_K_XL in llama.cpp.
|
||||
|
||||
Cost on the same tokens: 44.34 -> 44.26, 46.74 -> 46.56, 47.02 -> 46.83 tok/s (0.2-0.4%).
|
||||
|
||||
## Serve (`esp_serve.py`)
|
||||
|
||||
- Loaded and switched off (`cvec=0`) vs an engine without it: 65 / 65 first tokens after prefixes (verify windows
|
||||
and the batched prompt path) and three 256-token generations **token-identical**.
|
||||
- On, off, on again: identical (the switch drops the conversation cache, so nothing computed one way is reused the
|
||||
other way).
|
||||
- The prompt paths steer like the per-token path: served-with-vector first tokens agree with the per-token path's
|
||||
teacher-forced argmax with the vector 62 / 65, and with the stock one 57 / 65 (stock served: 64 / 65 and 57 / 65).
|
||||
- Decode tok/s of 3 x 256-token generations: stock 66.4, on 76.7 / 81.2. **Not a like-for-like comparison:** the
|
||||
model writes different text with it on (on the code prompt it copied a long stretch of the source, which prompt
|
||||
lookup drafts at 91% acceptance, where stock stopped after 78 tokens). On the same tokens it is 0.2-0.4% slower.
|
||||
@@ -0,0 +1,85 @@
|
||||
"""Teacher-forced logits, stock vs the experimental-speed-projection vector, on the same texts and fixed experts.
|
||||
|
||||
python esp_kl.py run # the dumps (per-token path)
|
||||
python esp_kl.py compare # same top-1, mean/median KL(stock || projection), perplexities
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
|
||||
S = os.path.dirname(os.path.abspath(__file__))
|
||||
E = r"C:\Users\AI-Server\Desktop\Strata\Public\Engine"
|
||||
EXE = E + r"\build-dev\strata.exe"
|
||||
VEC = r"C:\Users\AI-Server\Desktop\Strata\experimental-speed-projection\Qwen3.8-Flash-Next-experimental-speed-projection.gguf"
|
||||
TEXTS = {"code": S + r"\p512.ids", "doc": S + r"\4k-02-long-doc-1k.ids", "chat": S + r"\4k-04-chat-1k.ids"}
|
||||
OUT = S + r"\esp-kl"
|
||||
ARMS = {"stock": [],
|
||||
"proj": ["--control-vector-scaled", VEC + ":1.0", "--control-vector-layer-range", "4", "44",
|
||||
"--cvec-mode", "project", "--cvec-dir", "per-layer"]}
|
||||
|
||||
|
||||
def base_args():
|
||||
c = json.load(open(S + r"\cfg-rel.json"))
|
||||
a = list(c["args"])
|
||||
i = a.index("--expert-cache")
|
||||
a[i + 1] = "4000"
|
||||
j = a.index("--prefill") # the prompt one token at a time: a logits row per position
|
||||
del a[j:j + 2]
|
||||
return a + ["--pcie-frac", "0", "--adapt-swaps", "0"], c
|
||||
|
||||
|
||||
def run():
|
||||
os.makedirs(OUT, exist_ok=True)
|
||||
args, c = base_args()
|
||||
env = dict(os.environ)
|
||||
env["PATH"] = os.pathsep.join(c["lib_dirs"]) + os.pathsep + env["PATH"]
|
||||
for name, path in TEXTS.items():
|
||||
for arm, extra in ARMS.items():
|
||||
out = f"{OUT}\\{name}-{arm}.bin"
|
||||
if os.path.exists(out):
|
||||
continue
|
||||
cmd = [EXE, *args, *extra, "--tokens-file", path, "--max-new", "1", "--dump-logits", out]
|
||||
with open(f"{OUT}\\{name}-{arm}.log", "w") as log:
|
||||
r = subprocess.run(cmd, cwd=c["cwd"], stdout=log, stderr=subprocess.STDOUT, env=env)
|
||||
print(name, arm, "exit", r.returncode, flush=True)
|
||||
|
||||
|
||||
def load(p):
|
||||
h = np.fromfile(p, dtype=np.int32, count=2)
|
||||
return np.memmap(p, dtype=np.float32, mode="r", offset=8, shape=(int(h[1]), int(h[0])))
|
||||
|
||||
|
||||
def lsm(x):
|
||||
x = x.astype(np.float64)
|
||||
m = x.max(axis=-1, keepdims=True)
|
||||
return x - (m + np.log(np.exp(x - m).sum(axis=-1, keepdims=True)))
|
||||
|
||||
|
||||
def compare():
|
||||
print(f"{'text':<6}{'tokens':>7}{'same top-1':>11}{'mean KL':>9}{'median KL':>11}{'p99 KL':>8}{'ppl stock':>10}{'ppl proj':>9}")
|
||||
allkl = []
|
||||
for name, path in TEXTS.items():
|
||||
ids = [int(x) for x in open(path).read().replace(",", " ").split()]
|
||||
a, b = load(f"{OUT}\\{name}-stock.bin"), load(f"{OUT}\\{name}-proj.bin")
|
||||
n = min(a.shape[0], b.shape[0], len(ids) - 1)
|
||||
kl, same, la, lb = [], 0, [], []
|
||||
for r in range(0, n, 64):
|
||||
pa, pb = lsm(a[r:min(n, r + 64)]), lsm(b[r:min(n, r + 64)])
|
||||
kl += list((np.exp(pa) * (pa - pb)).sum(axis=1))
|
||||
same += int((pa.argmax(1) == pb.argmax(1)).sum())
|
||||
nxt = np.array(ids[r + 1:min(n, r + 64) + 1])
|
||||
la += list(pa[np.arange(len(nxt)), nxt])
|
||||
lb += list(pb[np.arange(len(nxt)), nxt])
|
||||
kl = np.array(kl)
|
||||
allkl += list(kl)
|
||||
print(f"{name:<6}{n:>7}{100 * same / n:>10.1f}%{kl.mean():>9.3f}{np.median(kl):>11.4f}{np.percentile(kl, 99):>8.2f}"
|
||||
f"{np.exp(-np.mean(la)):>10.3f}{np.exp(-np.mean(lb)):>9.3f}")
|
||||
allkl = np.array(allkl)
|
||||
print(f"all {len(allkl)} tokens: mean KL {allkl.mean():.3f}, max {allkl.max():.2f}, p99 {np.percentile(allkl, 99):.2f}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
{"run": run, "compare": compare}[sys.argv[1]]()
|
||||
@@ -0,0 +1,129 @@
|
||||
"""Serve-mode checks of the experimental-speed-projection vector (exact mode: fixed experts, no PCIe share).
|
||||
|
||||
python esp_serve.py run ARM # ARM = stock | vec; writes esp-serve/<arm>.json
|
||||
python esp_serve.py compare
|
||||
|
||||
Per arm: the first greedy token after many prefixes of three texts (short ones go through the verify windows, long
|
||||
ones through the batched prompt path; the conversation cache reuses the earlier prefix), and three 256-token greedy
|
||||
generations. The vec arm runs everything with cvec=1, then cvec=0, then cvec=1 again.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
|
||||
S = os.path.dirname(os.path.abspath(__file__))
|
||||
E = r"C:\Users\AI-Server\Desktop\Strata\Public\Engine"
|
||||
sys.path.insert(0, E)
|
||||
from serve.server import StrataEngine # noqa: E402
|
||||
|
||||
EXE = E + r"\build-dev\strata.exe"
|
||||
VEC = r"C:\Users\AI-Server\Desktop\Strata\experimental-speed-projection\Qwen3.8-Flash-Next-experimental-speed-projection.gguf"
|
||||
TEXTS = {"code": S + r"\p512.ids", "doc": S + r"\4k-02-long-doc-1k.ids", "chat": S + r"\4k-04-chat-1k.ids"}
|
||||
OUT = S + r"\esp-serve"
|
||||
VEC_ARGS = ["--control-vector-scaled", VEC + ":1.0", "--control-vector-layer-range", "4", "44",
|
||||
"--cvec-mode", "project", "--cvec-dir", "per-layer"]
|
||||
|
||||
|
||||
def ids_of(name):
|
||||
return [int(x) for x in open(TEXTS[name]).read().replace(",", " ").split()]
|
||||
|
||||
|
||||
def engine(extra):
|
||||
c = json.load(open(S + r"\cfg-rel.json"))
|
||||
a = list(c["args"])
|
||||
a[a.index("--expert-cache") + 1] = "4000"
|
||||
env = dict(os.environ)
|
||||
env["PATH"] = os.pathsep.join(c["lib_dirs"]) + os.pathsep + env["PATH"]
|
||||
return StrataEngine(EXE, a + ["--pcie-frac", "0", "--adapt-swaps", "0"] + extra, cwd=c["cwd"],
|
||||
log=OUT + r"\engine.log", env=env)
|
||||
|
||||
|
||||
def gen(eng, ids, n, sampling):
|
||||
toks = [t for t in eng.generate(ids, n, sampling, threading.Event()) if t is not None]
|
||||
return toks, dict(eng.last)
|
||||
|
||||
|
||||
def suite(eng, sampling):
|
||||
out = {"first": {}, "long": {}}
|
||||
for name in TEXTS:
|
||||
ids = ids_of(name)
|
||||
# short prefixes growing by 4 (each continues the live session through the verify windows), then long ones
|
||||
# SHRINKING (no cached prefix, so each is read from 0 by the batched prompt path)
|
||||
lens = list(range(32, 72, 4)) + list(range(min(len(ids) - 1, 700), 95, -48))
|
||||
out["first"][name] = {L: gen(eng, ids[:L], 1, sampling)[0][0] for L in lens}
|
||||
for name in TEXTS:
|
||||
toks, last = gen(eng, ids_of(name)[:300], 256, sampling)
|
||||
out["long"][name] = {"tokens": toks, "last": last}
|
||||
return out
|
||||
|
||||
|
||||
def run(arm):
|
||||
os.makedirs(OUT, exist_ok=True)
|
||||
eng = engine(VEC_ARGS if arm == "vec" else [])
|
||||
res = {"info": eng.info}
|
||||
if arm == "stock":
|
||||
res["stock"] = suite(eng, {})
|
||||
else:
|
||||
res["on"] = suite(eng, {"experimental_speed_projection": True})
|
||||
res["off"] = suite(eng, {"experimental_speed_projection": False})
|
||||
res["on2"] = suite(eng, {"experimental_speed_projection": True})
|
||||
eng.close()
|
||||
json.dump(res, open(f"{OUT}\\{arm}.json", "w"))
|
||||
print(arm, "done", eng.info, flush=True)
|
||||
|
||||
|
||||
def compare():
|
||||
import numpy as np
|
||||
sys.path.insert(0, S)
|
||||
from esp_kl import load, OUT as KL
|
||||
st = json.load(open(OUT + r"\stock.json"))
|
||||
ve = json.load(open(OUT + r"\vec.json"))
|
||||
print("engine INFO (vec):", ve["info"])
|
||||
|
||||
def eq_first(a, b):
|
||||
tot = same = 0
|
||||
for name in a:
|
||||
for L, t in a[name].items():
|
||||
tot += 1
|
||||
same += int(b[name][L] == t)
|
||||
return same, tot
|
||||
|
||||
def eq_long(a, b):
|
||||
return all(a[n]["tokens"] == b[n]["tokens"] for n in a), \
|
||||
[(n, next((i for i, (x, y) in enumerate(zip(a[n]["tokens"], b[n]["tokens"])) if x != y), None)) for n in a]
|
||||
|
||||
print("1. vector loaded, switched off == no vector")
|
||||
print(" first tokens: %d / %d identical" % eq_first(st["stock"]["first"], ve["off"]["first"]))
|
||||
print(" 256-token generations identical:", *eq_long(st["stock"]["long"], ve["off"]["long"]))
|
||||
print("2. repeatable: on, off, on again")
|
||||
print(" first tokens: %d / %d identical" % eq_first(ve["on"]["first"], ve["on2"]["first"]))
|
||||
print(" 256-token generations identical:", *eq_long(ve["on"]["long"], ve["on2"]["long"]))
|
||||
print("3. the prompt paths against the per-token path's teacher-forced argmax (row L-1 predicts token L)")
|
||||
for arm, first in (("stock", st["stock"]["first"]), ("on", ve["on"]["first"])):
|
||||
for ref in ("stock", "proj"):
|
||||
agree = tot = 0
|
||||
for name in first:
|
||||
d = load(f"{KL}\\{name}-{ref}.bin")
|
||||
for L, t in first[name].items():
|
||||
L = int(L)
|
||||
if L - 1 < d.shape[0]:
|
||||
tot += 1
|
||||
agree += int(int(np.argmax(d[L - 1])) == t)
|
||||
print(f" served {arm:<5} vs per-token {ref:<5}: {agree} / {tot}")
|
||||
print("4. how different the text is: 256-token generations, on vs stock, first difference")
|
||||
print(" ", eq_long(st["stock"]["long"], ve["on"]["long"])[1])
|
||||
print("5. decode speed (exact mode: fixed experts, no PCIe share - not the normal setup)")
|
||||
for label, r in (("stock", st["stock"]), ("vec off", ve["off"]), ("vec on", ve["on"]), ("vec on 2", ve["on2"])):
|
||||
g = sum(v["last"]["generated"] for v in r["long"].values())
|
||||
ms = sum(v["last"]["decode_ms"] for v in r["long"].values())
|
||||
acc = sum(v["last"].get("drafts_accepted", 0) for v in r["long"].values())
|
||||
off = sum(v["last"].get("drafts_offered", 0) for v in r["long"].values())
|
||||
print(f" {label:<9} {g / ms * 1000:6.1f} tok/s drafts accepted {acc}/{off}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if sys.argv[1] == "run":
|
||||
run(sys.argv[2])
|
||||
else:
|
||||
compare()
|
||||
@@ -0,0 +1,20 @@
|
||||
1. vector loaded, switched off == no vector
|
||||
first tokens: 65 / 65 identical
|
||||
256-token generations identical: True [('code', None), ('doc', None), ('chat', None)]
|
||||
2. repeatable: on, off, on again
|
||||
first tokens: 65 / 65 identical
|
||||
256-token generations identical: True [('code', None), ('doc', None), ('chat', None)]
|
||||
3. the prompt paths against the per-token path's teacher-forced argmax (row L-1 predicts token L)
|
||||
served stock vs per-token stock: 64 / 65
|
||||
served stock vs per-token proj : 57 / 65
|
||||
served on vs per-token stock: 57 / 65
|
||||
served on vs per-token proj : 62 / 65
|
||||
4. how different the text is: 256-token generations, on vs stock, first difference
|
||||
[('code', 11), ('doc', 6), ('chat', 3)]
|
||||
5. decode speed (exact mode: fixed experts, no PCIe share - not the normal setup)
|
||||
stock 66.4 tok/s drafts accepted 256/309
|
||||
vec off 65.7 tok/s drafts accepted 251/318
|
||||
vec on 76.7 tok/s drafts accepted 366/425
|
||||
vec on 2 81.2 tok/s drafts accepted 366/423
|
||||
|
||||
[exited with code 0]
|
||||
@@ -0,0 +1,6 @@
|
||||
text tokens same top-1 mean KL median KL p99 KL ppl stock ppl proj
|
||||
code 511 92.8% 0.098 0.0031 1.69 2.594 2.982
|
||||
doc 1023 89.8% 0.058 0.0271 0.84 30.299 30.984
|
||||
chat 1023 89.6% 0.050 0.0265 0.33 18.409 18.485
|
||||
all 2557 tokens: mean KL 0.063, max 4.10, p99 1.00
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
# 2026-09-27: Q4_0 KV with Hadamard rotation (PR #21, `--kv q4_0`)
|
||||
|
||||
PR #21 (code-martin) adds a 4-bit K/V format: an orthonormal 256-point Walsh-Hadamard rotation of K, V and Q, then
|
||||
ggml `q4_0` blocks (576 B per cell and layer, vs 1,056 B in int8).
|
||||
|
||||
## Integration fixes made on merge
|
||||
|
||||
- **Q4 + KV streaming (`--kv-resident`).** The PR had no host copy for Q4 and skipped the staging, so with streaming
|
||||
on, the prompt path wrote K/V through the residency map's -1 entries (out-of-bounds writes).
|
||||
- Q4 is now a third format in `kv_stream`: host copy, block residency, prompt-path staging, MTP ring and STATE_HASH.
|
||||
- `kv_stream_parity` checks it bitwise, streamed vs resident, with ring restore.
|
||||
- **Duplicate attention.** The per-token decode path ran attention twice, the first time before the selection's
|
||||
blocks were made resident; it now runs once.
|
||||
- **Tie-break.** The group maximum's tie-break is now deterministic across lanes: equal |x| with opposite signs
|
||||
could give one block two scales.
|
||||
- **Unrelated changes dropped:** duplicate path fixes (already in 0.1.7), personal `.gitignore` entries, and a
|
||||
re-encoded CMakeLists.
|
||||
|
||||
`kv_q4_parity` (the PR's test) and all 70 ctest tests pass.
|
||||
|
||||
## Quality (teacher-forced, `tools/kv_precision_compare.py`)
|
||||
|
||||
Same text, same fixed expert set (Q2_0, 3,000 slots, `--adapt-swaps 0`); only `--kv` differs. fp16 is the reference.
|
||||
|
||||
| Text | KV | Same top-1 as fp16 | Mean KL | Perplexity | vs fp16 (nats/token) |
|
||||
|---|---|---:|---:|---:|---:|
|
||||
| code agent (512) | int8 | 98.4% | 0.014 | 2.649 | -0.011 +- 0.006 |
|
||||
| | q4_0 | 95.7% | 0.030 | 2.598 | -0.031 +- 0.014 |
|
||||
| document (1,024) | int8 | 95.6% | 0.009 | 30.18 | +0.012 +- 0.005 |
|
||||
| | q4_0 | 91.3% | 0.039 | 32.26 | **+0.078 +- 0.011** |
|
||||
| chat (1,024) | int8 | 95.5% | 0.009 | 18.24 | -0.003 +- 0.005 |
|
||||
| | q4_0 | 90.7% | 0.028 | 18.52 | +0.012 +- 0.008 |
|
||||
| document, 8K (every 8th position) | int8 | 92.3% | 0.114 | 7.63 | -0.013 +- 0.020 |
|
||||
| | q4_0 | 88.0% | 0.297 | 8.65 | **+0.112 +- 0.037** |
|
||||
|
||||
- **int8 is indistinguishable from fp16** (within about 2 standard errors everywhere).
|
||||
- **q4_0 costs measurable precision, and more as the context grows:**
|
||||
- document perplexity +8% at 1K and +12% at 8K;
|
||||
- the KL from fp16 is 2.6-4.2x int8's;
|
||||
- code and chat are near-neutral.
|
||||
- **Needles with `--kv q4_0 --kv-resident 32768`: 5/5** (1K, 32K, 128K at 10% and 90% depth, 262K;
|
||||
`needles-q4.*`). Retrieval holds.
|
||||
|
||||
## Speed and memory (Q2_0, 128K, matrix bench, `--kv-resident 32768`)
|
||||
|
||||
| KV | Expert slots | Decode tok/s | Tokens/round | Rounds/s | K/V in RAM |
|
||||
|---|---:|---:|---:|---:|---:|
|
||||
| int8 (`kv-stream/matrix-stream`) | 4,044 | 62.4 | 2.52 | 24.8 | 1.52 GiB |
|
||||
| q4_0 (`matrix-q4`) | 4,190 | 67.4 | 2.62 | 25.7 (+3.7%) | 0.83 GiB |
|
||||
|
||||
Without streaming (contexts up to 64K, or too little RAM for it) q4_0 halves the whole KV cache in VRAM instead.
|
||||
|
||||
## Decision
|
||||
|
||||
`--kv q4_0` is a user option:
|
||||
- `START-HERE.bat --kv q4_0`, or the question setup asks above 8K context;
|
||||
- or `--kv q4_0` in a `strata-*.json`.
|
||||
|
||||
int8 stays the default: every published quality number was measured with it, and q4_0's precision cost is real,
|
||||
though it passes the needles.
|
||||
BIN
Binary file not shown.
+26
@@ -0,0 +1,26 @@
|
||||
{
|
||||
"mode": "project",
|
||||
"dir": "per-layer",
|
||||
"scale": 1.0,
|
||||
"layer_range": [
|
||||
4,
|
||||
44
|
||||
],
|
||||
"refusal_harmful_thinkoff": 2.0,
|
||||
"refusal_harmful_thinkon": 2.0,
|
||||
"refusal_harmless_thinkoff": 4.0,
|
||||
"refusal_harmless_thinkon": 6.0,
|
||||
"broken": 0,
|
||||
"kl_mean": 0.18598,
|
||||
"kl_max": 18.26549,
|
||||
"kl_p99": 3.143571,
|
||||
"decode_tps": 51.19,
|
||||
"vector_file": "Qwen3.8-Flash-Next-experimental-speed-projection.gguf",
|
||||
"base_model_gguf": "unsloth/Qwen3.8-Flash-Next-GGUF UD-Q2_K_XL",
|
||||
"base_model_sha256_shard1": "a4f3b21e77353999829f2f767e9ac21ce9c71d29a74f2cc9eda48c9bf23c8b86",
|
||||
"worktree_commit": "37e026e3b",
|
||||
"criterion_status": "PASS",
|
||||
"dirty_direction": false,
|
||||
"note": "projection ablation h -= s*(h.v)*v, v unit-normalized per layer. dir=per-layer",
|
||||
"branch": "cvec-hooks (github.com/Cudila/llama.cpp)"
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
# experimental-speed-projection (EXPERIMENTAL, off by default)
|
||||
|
||||
`Qwen3.8-Flash-Next-experimental-speed-projection.gguf` is a 480 KB control vector for Qwen3.8-Flash-Next: one unit
|
||||
direction of 2,560 values per layer (`direction.1` .. `direction.47`, GGUF `controlvector` format). The JSON beside it
|
||||
is the configuration its authors selected and their scores.
|
||||
|
||||
**What it does.** Turned on, Strata removes each direction from the residual stream after layers 4-44
|
||||
(`h -= (h . v) v` on every hyper-connection stream), the same operation as llama.cpp's `--cvec-mode project` in the
|
||||
package's patches. The package's own documentation describes the vector as a **refusal-direction projection**: the
|
||||
model declines far fewer requests (it reports 1 of 50 vs 50 of 50 on its test set), and removing refusals removes a
|
||||
safety behaviour - you are responsible for what the model writes with it on. It also shifts the model's predictions
|
||||
slightly on ordinary text (measured here: `bench/results/2026-09-27-esp/`). It is not an optimization in the engine:
|
||||
on the same text it costs 0.2-0.4% per token; a chat's speed with it on depends on the text the model writes.
|
||||
|
||||
**Turning it on.** `START-HERE.bat --setup` asks (default: off), or pass `--experimental-speed-projection on`. With it
|
||||
loaded, the web app's Sampling drawer and the API field `"experimental_speed_projection": false` switch it off per
|
||||
request. See `docs/DETAILS.md`, "Experimental speed projection".
|
||||
|
||||
**Origin and license.** A local package of the vector (the published original uses filenames containing "refusal";
|
||||
the bytes are the same), made from Qwen3.8-Flash-Next activations, so the Qwen Community License 1.0 of the model
|
||||
applies to it. Made for the original Qwen3.8-Flash-Next (not Swift 1.5).
|
||||
+419
@@ -0,0 +1,419 @@
|
||||
# Strata - the details
|
||||
|
||||
The technical side of Strata: every measured number, the API, images, all settings and how the engine works.
|
||||
New here? Start with the [README](../README.md) - it has everything you need to install and use it.
|
||||
|
||||
> **On this page:** [Speed](#speed-measured) · [Other GPUs](#other-gpus-estimated) · [Which model?](#which-model) ·
|
||||
> [Requirements](#before-you-start) · [Windows](#windows) · [Linux](#linux) · [API](#using-it) · [Images](#images-vision) ·
|
||||
> [Troubleshooting](#troubleshooting) · [How it works](#how-it-works)
|
||||
|
||||
---
|
||||
|
||||
## Speed (measured)
|
||||
|
||||
RTX 5070 **12 GB**, Ryzen 5 7600 (6 cores), 64 GB DDR5-5200, Windows. One code-agent prompt per length, 256 generated
|
||||
tokens, MTP speculative decoding on. "262K" is the model's full context window (a 259,943-token prompt).
|
||||
|
||||
### Prompt processing (tokens/s)
|
||||
|
||||
| Model | 1K | 4K | 32K | 64K | 128K | 262K |
|
||||
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
|
||||
| **Q2_0** | 389 | 539 | 571 | 561 | 543 | 496 |
|
||||
| **IQ2_XS** | 332 | 463 | 495 | 486 | 472 | 437 |
|
||||
| **IQ3_XXS** | 285 | 410 | 435 | 427 | 414 | - |
|
||||
| **IQ3_S** | 260 | 374 | 397 | - | 378 | - |
|
||||
|
||||
### Output (tokens/s)
|
||||
|
||||
| Model | 1K | 4K | 32K | 64K | 128K | 262K |
|
||||
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
|
||||
| **Q2_0** | 88.7 | 94.6 | 87.5 | 76.4 | 65.1 | 56.3 |
|
||||
| **IQ2_XS** | 82.0 | 78.0 | 65.3 | 63.7 | 52.0 | 48.0 |
|
||||
| **IQ3_XXS** | 64.6 | 65.6 | 57.3 | 54.4 | 44.8 | - |
|
||||
| **IQ3_S** | 51.2 | 54.4 | 51.1 | - | 42.2 | - |
|
||||
|
||||
IQ3_XXS and IQ3_S at 262K are not measured: with their 43 / 50 GB of experts, a 260K-token context brings a 64 GB PC
|
||||
to its memory limit. Use up to 128K with them on 64 GB (setup caps it). IQ3_S (engine 0.1.4 or newer) is only published
|
||||
for the original model, not for Swift 1.5.
|
||||
|
||||
**KV streaming (engine 0.1.5):** at 64K and more, setup keeps the context's KV cache in RAM and only the part the
|
||||
attention reads in VRAM (`--kv-resident 32768`), so more experts fit on the GPU. Q2_0 at 262K: 50.9 -> 62.6 tokens/s
|
||||
(1,589 -> 3,872 experts in VRAM); at 128K about +6%. The attention reads exactly the same values (only where the KV lives changes); it
|
||||
costs ~13.7 KB of RAM per context token (1.7 GB at 128K). Existing installs: run `START-HERE.bat --setup` once to turn
|
||||
it on.
|
||||
|
||||
**4-bit KV cache (engine 0.1.8, optional):** `START-HERE.bat --setup` asks above 8K context (or pass `--kv q4_0`). It
|
||||
halves the KV cache's memory with a Hadamard rotation before 4-bit rounding (PR #21), about 4% faster at 128K, but it
|
||||
is measurably less precise on long documents (perplexity +8-12%; needle tests still pass). 8-bit stays the default.
|
||||
Details: [`bench/results/2026-09-27-kv-q4`](../bench/results/2026-09-27-kv-q4/README.md).
|
||||
|
||||
Time to first token is prompt length / prompt speed: about 7 s at 4K, 55 s at 32K, 4 minutes at 128K and 9 minutes at
|
||||
262K. The raw numbers: [`bench/results/`](../bench/results/). The [paper](paper/Strata-Paper.pdf) explains every number.
|
||||
|
||||
## Other GPUs (estimated)
|
||||
|
||||
Not measured - estimated from the runs above (same CPU and 64 GB RAM): the GPU part scaled by memory bandwidth, the CPU
|
||||
part by how many more experts the card's VRAM holds. Treat as **±20%**. Numbers are *prompt / output* tokens/s.
|
||||
|
||||
| GPU | Model | 1K | 4K | 32K | 64K | 128K | 262K |
|
||||
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
|
||||
| RTX 5060 Ti 16GB | Q2_0 | ~341 / ~80 | ~472 / ~87 | ~501 / ~81 | ~492 / ~72 | ~476 / ~62 | ~435 / ~53 |
|
||||
| | IQ2_XS | ~291 / ~80 | ~406 / ~77 | ~434 / ~63 | ~426 / ~62 | ~413 / ~51 | ~383 / ~47 |
|
||||
| | IQ3_XXS | ~249 / ~66 | ~359 / ~65 | ~381 / ~56 | ~374 / ~54 | ~363 / ~45 | - |
|
||||
| RTX 3090 24GB | Q2_0 | ~355 / ~128 | ~491 / ~140 | ~521 / ~130 | ~512 / ~115 | ~495 / ~100 | ~453 / ~85 |
|
||||
| | IQ2_XS | ~303 / ~131 | ~422 / ~128 | ~451 / ~103 | ~444 / ~102 | ~430 / ~85 | ~398 / ~78 |
|
||||
| | IQ3_XXS | ~260 / ~106 | ~374 / ~103 | ~396 / ~89 | ~390 / ~85 | ~378 / ~71 | - |
|
||||
|
||||
More VRAM matters more than a faster GPU: every extra GB holds ~700 more experts, and every expert on the GPU is one the
|
||||
CPU does not have to compute. A 3090's 24 GB takes most of the CPU work away.
|
||||
|
||||
## Which model?
|
||||
|
||||
All three are [ISTA-DASLab's GSQ-RCO quantizations](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF)
|
||||
of [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next).
|
||||
|
||||
| Model | Download | RAM it uses | Speed | Quality |
|
||||
| --- | ---: | ---: | --- | --- |
|
||||
| **Q2_0** | 66 GB | ~34 GB experts + ~6 GB | fastest | good |
|
||||
| **IQ2_XS** | 68 GB | ~36 GB experts + ~6 GB | close to Q2_0 | a bit better |
|
||||
| **IQ3_XXS** | 76 GB | ~43 GB experts + ~6 GB | slower (more CPU work) | best |
|
||||
|
||||
With 64 GB of RAM all three fit (close the browser for IQ3_XXS, and keep its context at 128K or less). With 48 GB only Q2_0 / IQ2_XS may fit. 32 GB is not enough.
|
||||
|
||||
### Or: Swift 1.5 (a fine-tune that thinks shorter)
|
||||
|
||||
The setup's first question also offers **[Swift 1.5](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF)**,
|
||||
UkisAI's fine-tune of Qwen3.8-Flash-Next, trained to reach the answer with much less thinking (its authors: 63% fewer
|
||||
thinking tokens, 1.8x sooner answers, under 1% accuracy loss). Same architecture, the same three sizes, its own
|
||||
vision encoder; Strata runs it at the same speed (4K, IQ2_XS: 465 prompt / 78.7 output tokens/s, vs 467 / 78.3 for
|
||||
the original). Its authors recommend **IQ2_XS** (their Q2_0 is marked experimental). Its license is the Swift Open
|
||||
License 1.0 - read it on the model page.
|
||||
|
||||
Our small check (8 reasoning questions, default thinking, IQ2_XS): both models got **8/8**; Swift used **1,234**
|
||||
output tokens in 28 s, the original **2,682** in 46 s - most of the difference from one question the original
|
||||
thought about for 1,524 tokens. Not a benchmark, but consistent with the claim.
|
||||
|
||||
```
|
||||
START-HERE.bat --setup --family swift --model IQ2_XS
|
||||
```
|
||||
|
||||
## Before you start
|
||||
|
||||
You need **only an NVIDIA driver** (version 580 or newer; update it with the NVIDIA App or from
|
||||
[nvidia.com/drivers](https://www.nvidia.com/drivers)). Everything else is installed for you the first time.
|
||||
|
||||
| | |
|
||||
| --- | --- |
|
||||
| GPU | NVIDIA **RTX 30, 40 or 50 series**, **12 GB VRAM or more** (8 GB runs, slowly). Measured on an RTX 5070; RTX 30/40 are untested. |
|
||||
| RAM | **64 GB** recommended (see the table above). |
|
||||
| CPU | x86-64 with AVX2 (any Intel/AMD desktop CPU from the last ~8 years). AVX-512 (Ryzen 7000/9000) is a bit faster. |
|
||||
| Disk | ~70-80 GB free for the model, ~6 GB for the MTP layer (+1 GB with images). **Q2_0 on an AVX-512 CPU** also writes a one-time ~40 GB copy of its experts for the fast CPU kernel. An NVMe SSD is strongly recommended. |
|
||||
| OS | Windows 10/11, or Linux (Ubuntu 22.04/24.04 get everything installed automatically). |
|
||||
|
||||
What the first start installs, all inside this folder (`.venv/`, `engine/`, `third_party/`, `models/`, `packs/`, `mtp/`):
|
||||
Python 3.12 if you have none (for your user account, no admin), a private Python environment, NVIDIA's CUDA libraries
|
||||
(from pip, ~0.4 GB), the ready-made Strata engine for RTX 30/40/50, the model and the MTP draft layer. If no
|
||||
ready-made engine fits your PC, it offers to install the build tools (Visual Studio Build Tools + CUDA Toolkit on
|
||||
Windows, `build-essential` + CUDA on Ubuntu) and compiles the engine for your GPU (asks first; 20-40 minutes once).
|
||||
|
||||
---
|
||||
|
||||
## Windows
|
||||
|
||||
### Double-click `START-HERE.bat`
|
||||
|
||||
**The first time** it asks four questions and does the rest:
|
||||
|
||||
1. **Which model?** Qwen3.8-Flash-Next (the original) or Swift 1.5 (the fine-tune that thinks shorter).
|
||||
2. **Which size?** Q2_0, IQ2_XS or IQ3_XXS (it recommends one for your RAM).
|
||||
3. **How much context?** 8K to 256K tokens (it recommends one for your VRAM).
|
||||
4. **Images?** yes / no (see [Images](#images-vision)).
|
||||
|
||||
Then it downloads and prepares everything (the model is 66-76 GB, so the first start takes a while; an interrupted
|
||||
download continues where it stopped) and **starts the model**: your browser opens `http://127.0.0.1:8080`, the Strata
|
||||
app. It has three tabs:
|
||||
- **Chat:** streaming answers, the model's thinking (folded away once it answers), code with a copy button, pictures when
|
||||
images are on, and sampling and thinking-level settings. Chats stay in your browser.
|
||||
- **Monitor:** what the model is doing (reading the prompt, with progress, or writing, at how many tokens/s); GPU load,
|
||||
VRAM, temperature, power and PCIe traffic; CPU, RAM and disk; the context in use; the last requests.
|
||||
- **About:** the model and engine settings, and the addresses to connect other apps.
|
||||
|
||||
`http://127.0.0.1:8080/?q=your question` opens it with a new chat already asking. The API is at
|
||||
`http://127.0.0.1:8080/v1` for your apps.
|
||||
|
||||
**Every time after that**, `START-HERE.bat` just starts the model (30-90 s to load 34-43 GB into RAM). Nothing is
|
||||
downloaded again. Closing the window stops the model.
|
||||
|
||||
```
|
||||
START-HERE.bat --setup install another model, or change context / images
|
||||
START-HERE.bat --model IQ2_XS --context 32768 --vision yes --yes no questions
|
||||
START-HERE.bat --gguf-dir D:\models\IQ2_XS use GGUF files you already have
|
||||
START-HERE.bat --port 8081 another port
|
||||
```
|
||||
|
||||
With more than one model installed, it asks which one to start. `run-<model>.bat` starts a model directly.
|
||||
|
||||
### Chat in the terminal (optional)
|
||||
|
||||
```
|
||||
.venv\Scripts\python chat.py
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Linux
|
||||
|
||||
```bash
|
||||
./setup.sh
|
||||
```
|
||||
|
||||
The same questions, the same automatic install (it uses `sudo apt` for Python and, only if it has to compile,
|
||||
for the build tools), and the same start: `http://127.0.0.1:8080`. Later runs of `./setup.sh` (or `./run-<model>.sh`)
|
||||
start the model directly. Options as on Windows (`./setup.sh --setup`, `--model Q2_0 --yes`, `--gguf-dir /data/Q2_0`).
|
||||
Terminal chat: `.venv/bin/python chat.py`.
|
||||
|
||||
---
|
||||
|
||||
## Using it
|
||||
|
||||
The server listens on `http://127.0.0.1:8080` (change with `--port` in setup, or edit the run script).
|
||||
|
||||
| API | Endpoint |
|
||||
| --- | --- |
|
||||
| OpenAI Chat Completions (stream and non-stream, tools) | `POST /v1/chat/completions` |
|
||||
| Anthropic Messages (stream and non-stream, tools) | `POST /v1/messages` |
|
||||
| Model list / health | `GET /v1/models`, `GET /health` |
|
||||
| What the model is doing right now | `GET /status` |
|
||||
| Everything the Monitor tab shows (engine, live state, last requests, hardware) | `GET /metrics` |
|
||||
|
||||
```bash
|
||||
curl http://127.0.0.1:8080/v1/chat/completions -H "Content-Type: application/json" -d '{
|
||||
"model": "strata", "messages": [{"role": "user", "content": "Write a haiku about GPUs."}], "max_tokens": 512 }'
|
||||
```
|
||||
|
||||
```python
|
||||
from openai import OpenAI
|
||||
client = OpenAI(base_url="http://127.0.0.1:8080/v1", api_key="none")
|
||||
r = client.chat.completions.create(model="strata", messages=[{"role": "user", "content": "Hello!"}])
|
||||
print(r.choices[0].message.content)
|
||||
```
|
||||
|
||||
- **Thinking levels: none, low, medium, high.** The model thinks before it answers (streamed as
|
||||
`reasoning_content`, Anthropic: `thinking` blocks). Choose how much per request - in the chat page (the "Thinking"
|
||||
menu), in `chat.py` (`/think low`), or over the API:
|
||||
|
||||
| API | how |
|
||||
| --- | --- |
|
||||
| OpenAI | `"reasoning_effort": "none" \| "low" \| "medium" \| "high"` (also `"reasoning": {"effort": ...}`, or `"chat_template_kwargs": {"enable_thinking": false}`) |
|
||||
| Anthropic | `"output_config": {"effort": "low" \| "medium" \| "high"}`, `"thinking": {"type": "disabled"}`, or `"thinking": {"type": "enabled", "budget_tokens": N}` (under 2K = low, under 8K = medium, more = high) |
|
||||
|
||||
Without a setting the model uses its own default, **high**. `none` answers at once (fastest); `low` keeps the thinking
|
||||
short. The levels are instructions the model was trained with, not a hard token limit: on easy questions all three
|
||||
think briefly, on hard ones `high` thinks longest and is most accurate.
|
||||
- **Streaming.** With `"stream": true` everything arrives as it is made: the thinking, the answer, and tool calls
|
||||
(the tool's name first, then its arguments piece by piece, like OpenAI and Anthropic do). While the model reads a
|
||||
long prompt the stream sends keep-alives, so agents do not time out; the server window prints progress every
|
||||
15 s, and `GET /status` says what it is doing (`reading the prompt`, `answering`, tokens so far). Closing the
|
||||
connection or pressing stop in your app really stops the model, so the next request starts at once.
|
||||
- **Chat apps.** Any app with an "OpenAI-compatible" provider works: base URL `http://127.0.0.1:8080/v1`, any API key.
|
||||
- **Context.** Chosen in setup (8K-262K). Requests longer than that are refused, never silently cut. A request whose
|
||||
`max_tokens` would run past the context is refused too (400); agents that always ask for their full output cap
|
||||
can instead get it shortened to the room left: add `"fit_max_tokens": true` to `strata-<model>.json` (or pass
|
||||
`--fit-max-tokens` to `serve/server.py`). A prompt that leaves no room at all is still refused.
|
||||
- **From other devices on your network.** The server listens on your PC only (`127.0.0.1`) unless you say otherwise:
|
||||
run setup with `START-HERE.bat --setup --host 0.0.0.0 --api-key some-long-secret` (or add `"host": "0.0.0.0"` and
|
||||
`"api_key": "..."` to `strata-<model>.json`). The server window then prints this PC's addresses
|
||||
(`from other devices: http://192.168.x.x:8080/`); open that on the other device, or use `.../v1` as an API base URL.
|
||||
On Windows the firewall blocks it until you allow it: accept its prompt for Python (private networks), or run
|
||||
`New-NetFirewallRule -DisplayName "Strata 8080" -Direction Inbound -Protocol TCP -LocalPort 8080 -Action Allow -Profile Private`
|
||||
in an admin PowerShell, and make sure the network is set to Private.
|
||||
- **From the internet.** Put a tunnel in front of it, for example [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/do-more-with-tunnels/trycloudflare/):
|
||||
`cloudflared tunnel --url http://127.0.0.1:8080`. **Set a key first**, or anyone with the link can use your PC:
|
||||
add `"api_key": "some-long-secret"` to `strata-<model>.json` (or set the `STRATA_API_KEY` environment variable);
|
||||
clients then send it as their API key.
|
||||
|
||||
**Conversation cache.** A request that continues a chat reads only the part after what the engine already holds: the
|
||||
live session, or one of the checkpoints it keeps in RAM (up to 6, ~118 MB each, taken at the start of each new
|
||||
assistant turn and every 16K prompt tokens). A checkpoint is used only when the prompt starts with exactly its tokens
|
||||
and pictures. Engine options: `--prompt-cache N` (0 = off), `--prompt-cache-every N`, `--turn-token ID`.
|
||||
|
||||
**Current limits (v1):** one request at a time, and one conversation cached at a time (switching between two chats
|
||||
re-reads the other one); images only when set up with them (below); no video. **Temperature / top_p / top_k / min_p /
|
||||
seed** are honored per request (OpenAI and Anthropic fields); with the default adaptive expert tier a sampled result
|
||||
is not reproducible run to run - for seed-reproducible output add `--adapt-every 100000` (static residency) to the
|
||||
engine arguments. The run config's optional `sampling` block sets the defaults for requests that leave the fields out
|
||||
(`"sampling": {"temperature": 1.0, "top_p": 0.95, "top_k": 20}`); a request's own fields always win, and with no
|
||||
block at all a request without sampling keys decodes greedy. The penalties (`presence_penalty`, `frequency_penalty`,
|
||||
`repetition_penalty`, with `penalty_last_n` capping how many recent tokens they count over, default 64 when any
|
||||
penalty is set) ride the same path; they count the tokens the request has consumed, so a repetition penalty
|
||||
suppresses what the model itself just said, not the prompt alone.
|
||||
|
||||
---
|
||||
|
||||
## Images (vision)
|
||||
|
||||
The model has a vision encoder: [`mmproj-Qwen3.8-Flash-Next-BF16.gguf`](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF)
|
||||
(0.9 GB, a 27-layer ViT plus the projector into the language model). It is **optional**: say yes when the setup asks
|
||||
"Images?", or run it again with `--vision gpu` (or `--vision cpu`). The setup downloads the encoder, builds a small
|
||||
helper (`strata-vision`, from llama.cpp's `mtmd` library) and adds it to your start script. Nothing else changes.
|
||||
|
||||
| Encoder on | Time per picture | Cost |
|
||||
| --- | --- | --- |
|
||||
| **GPU** (recommended) | **0.1-0.5 s** (up to 1,024 image tokens) | ~1.4 GB of VRAM is kept free for it, so the expert cache is smaller: text output is a few % slower (table below) |
|
||||
| CPU | 10-30 s (pictures are scaled down to ~300 image tokens) | nothing on the GPU |
|
||||
|
||||
A picture becomes up to 1,024 tokens of the context (a 640x480 photo: 300). The same picture sent again, as chat apps
|
||||
do on every turn, is encoded only once.
|
||||
|
||||
### Sending a picture
|
||||
|
||||
**Terminal chat:** type `/image <path to a picture>`, press Enter, then type your question.
|
||||
|
||||
```
|
||||
you> /image C:\Users\me\Pictures\receipt.jpg
|
||||
(picture attached: receipt.jpg - now type your question)
|
||||
you> What is the total on this receipt?
|
||||
```
|
||||
|
||||
**OpenAI API** (an `image_url` part: a `data:` URL, an `http(s)://` URL or a local file path):
|
||||
|
||||
```python
|
||||
import base64
|
||||
from openai import OpenAI
|
||||
client = OpenAI(base_url="http://127.0.0.1:8080/v1", api_key="none")
|
||||
img = base64.b64encode(open("photo.jpg", "rb").read()).decode()
|
||||
r = client.chat.completions.create(model="strata", messages=[{"role": "user", "content": [
|
||||
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img}"}},
|
||||
{"type": "text", "text": "What is in this picture?"}]}])
|
||||
print(r.choices[0].message.content)
|
||||
```
|
||||
|
||||
**Anthropic API:** an `image` block with a `base64` (or `url`) source, as usual.
|
||||
|
||||
JPEG, PNG, BMP, GIF, WebP, TIFF and AVIF work (the last ones are converted to PNG first; agents such as omp send
|
||||
WebP). Chat apps with image upload work the same way.
|
||||
|
||||
### Speed with images on (4K context, measured)
|
||||
|
||||
| Model | Prompt tok/s, images off | Prompt tok/s, images on | Output tok/s, images off | Output tok/s, images on |
|
||||
| --- | ---: | ---: | ---: | ---: |
|
||||
| **Q2_0** | 541 | 531 | 90.7 | 86.9 |
|
||||
| **IQ2_XS** | 468 | 458 | 77.1 | 74.0 |
|
||||
| **IQ3_XXS** | 411 | 401 | 64.7 | 59.5 |
|
||||
|
||||
"Off" is the published setup; "on" runs with the encoder loaded on the GPU and its VRAM kept free, so ~1,000 fewer
|
||||
experts fit in VRAM and the CPU computes a few more per token: 2-8% slower. For text, turning images on changes
|
||||
nothing else (the output is bit-identical when the VRAM is the same).
|
||||
|
||||
A question about a picture (a 640x480 newspaper page = 300 image tokens, a 328-token prompt; the whole request, encoder
|
||||
on the GPU, measured through the API):
|
||||
|
||||
| Model | Answer ("MEN WALK ON MOON") | Picture encoded | Prompt | Output |
|
||||
| --- | ---: | ---: | ---: | ---: |
|
||||
| **Q2_0** | 1.9 s | ~0.1 s | 207 tok/s | 65-73 tok/s |
|
||||
| **IQ2_XS** | 2.3 s | ~0.1 s | 173 tok/s | 50-60 tok/s |
|
||||
| **IQ3_XXS** | 2.7 s | ~0.1 s | 144 tok/s | 41-50 tok/s |
|
||||
|
||||
(Short prompts run below the 4K prompt speed: a 2,048-token chunk is where the prompt path is efficient. Short answers
|
||||
run below the long-output speed: the first rounds have no draft yet.)
|
||||
|
||||
**How it works inside:** the encoder turns the picture into rows of the same width as the model's word embeddings;
|
||||
Strata puts them where the prompt has `<|image_pad|>` tokens and gives each one its 2-D position (row and column in the
|
||||
picture; the model uses interleaved M-RoPE). Answers match llama.cpp's multimodal implementation token for token on our
|
||||
test images.
|
||||
|
||||
---
|
||||
|
||||
## Experimental speed projection (EXPERIMENTAL, off by default)
|
||||
|
||||
**This is an experiment, not a finished feature.** It ships with Strata but stays off unless you turn it on.
|
||||
|
||||
A 480 KB control vector for Qwen3.8-Flash-Next (`data/experimental-speed-projection/`, see its README). After each
|
||||
of layers 4-44 the engine removes one direction from every hyper-connection stream of the residual: `h -= (h . v) v`,
|
||||
one unit vector `v` per layer, exactly as llama.cpp does with the package's `--cvec-mode project` patches.
|
||||
|
||||
**What it changes.** The vector's own package describes it as a **refusal-direction projection**: with it the model
|
||||
declines far fewer requests (it reports 1 of 50 vs 50 of 50 on its test set), and removing refusals removes a safety
|
||||
behaviour - you are responsible for what the model writes with it on. It also shifts ordinary answers a little
|
||||
(measured below). It is not an optimization in the engine: on the same text it costs 0.2-0.4% per token. What a
|
||||
chat's tokens/s does with it on depends on the text the model writes (length, repetition, how well the drafts land),
|
||||
so measure it on your own prompts; the Monitor marks every request ESP or stock.
|
||||
|
||||
**Turning it on (at setup).** `START-HERE.bat --setup` asks "Turn on the experimental speed projection?" (default:
|
||||
no), or pass `--experimental-speed-projection on` (`off`, or a path to another vector GGUF). Only for the original
|
||||
Qwen3.8-Flash-Next, not Swift 1.5. It writes these engine flags (llama.cpp's) into `strata-<model>.json`:
|
||||
|
||||
```
|
||||
--control-vector-scaled <Strata>\data\experimental-speed-projection\Qwen3.8-Flash-Next-experimental-speed-projection.gguf:1.0
|
||||
--control-vector-layer-range 4 44 --cvec-mode project --cvec-dir per-layer
|
||||
```
|
||||
|
||||
The engine log then says `control vector mode = project, dir = per-layer, layers 4..44 (41 steered)`, and the web
|
||||
app's About tab lists it. (`--cvec-mode add` is llama.cpp's stock additive mode, for additive vectors.)
|
||||
|
||||
**Per request.** A loaded vector is on for every request unless it says otherwise: the web app's Sampling drawer has
|
||||
a switch, and the API takes `"experimental_speed_projection": false` in the request body (OpenAI and Anthropic; a
|
||||
config default goes in `"sampling": {"experimental_speed_projection": false}`). Switching drops the conversation
|
||||
cache once, since the model state was computed the other way. Switched off, the output is token-for-token the stock
|
||||
model's.
|
||||
|
||||
**Measured here** (Q2_0, fixed experts, 2,557 teacher-forced tokens of code, a document and a chat): the top-1 token
|
||||
changes at 10% of positions, mean KL from the stock model 0.063 nats (max 4.1), perplexity +15% on code, +2.3% on
|
||||
the document, +0.4% on the chat. Details: `bench/results/2026-09-27-esp/`.
|
||||
|
||||
---
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
| Symptom | What to do |
|
||||
| --- | --- |
|
||||
| `the NVIDIA driver is too old` | Update the driver (NVIDIA App or nvidia.com/drivers), restart, run `START-HERE.bat` again. |
|
||||
| Python or the build tools could not be installed | Install what it names (links are printed), then run it again. Everything already done is kept. |
|
||||
| `port 8080 is already in use` | Strata is already running (look for its window), or another program uses the port: `START-HERE.bat --port 8081`. |
|
||||
| `cudaHostRegister ... out of memory` in the log | Normal on Windows: the engine pins the experts in per-layer slices instead. Only a problem if the load then fails. |
|
||||
| The first start takes minutes | It is reading 34-43 GB into RAM; the second start is faster while the files are in the OS cache. |
|
||||
| Slow output, disk light busy | Not enough free RAM: close other programs, or choose Q2_0 / IQ2_XS. |
|
||||
| `prompt ... exceeds the context` | The request is longer than the context you chose: run setup again with a bigger `--context`. |
|
||||
| Slower than the tables | The monitor plugged into the GPU and other GPU programs take VRAM from the expert cache; RAM running below its rated speed (enable EXPO/XMP in the BIOS) slows the CPU half. |
|
||||
| `this server was started without the vision encoder` | The model was set up for text only: run setup again with `--vision gpu`. |
|
||||
| A picture is refused or `cannot read the image` | The file is not a picture Pillow can open (JPEG, PNG, WebP, GIF, BMP, TIFF, AVIF work). |
|
||||
| Pictures are slow (10-30 s) | The encoder runs on the CPU: run setup again with `--vision gpu` (needs ~1.4 GB of VRAM). |
|
||||
| A request never finishes (older engines, mostly with pictures) | Run `START-HERE.bat` once to get engine 0.1.2 or newer. It keeps a real margin of VRAM free: the log says `... MiB of VRAM free with everything loaded` and warns when it is close to 0. |
|
||||
| Anything else | The engine log is `strata-<model>.log` in this folder. |
|
||||
|
||||
---
|
||||
|
||||
## How it works
|
||||
|
||||
<p align="center"><img src="paper/tiers.svg" width="760" alt="memory tiers"></p>
|
||||
|
||||
- **GPU (VRAM):** attention and DeltaNet mixers, the gated-residual weights, routers, shared experts, output head, the MTP
|
||||
draft layer, the KV cache (from 64K: only its most-read part, the rest streams from RAM), and an **expert cache** that fills the rest of VRAM with the most-used experts (it adapts to
|
||||
the conversation while you chat).
|
||||
- **RAM:** all 24,576 experts, pinned. The CPU computes the experts that are not on the GPU **in place**, at the same time
|
||||
as the GPU works on the cached ones (AVX-512 / AVX2 kernels, ggml's for the i-quants).
|
||||
- **SSD:** the 28.8 GB n-gram table, read a few rows per token through the OS cache.
|
||||
- **Speculation:** the model's own MTP layer drafts up to 3 tokens; one pass over all 48 layers checks them. 2.4-3.2
|
||||
tokens per pass on average. When the reply repeats the context (code edits, quoted text), **prompt lookup** (engine
|
||||
0.1.7) drafts up to 5 tokens from the earlier copy, but only where its measured acceptance and cost say it pays:
|
||||
code edits 6-11% faster, other text unchanged. The drafts are checked like the MTP's, so the output is the same.
|
||||
- **Prompts** are processed in 2,048-token chunks with the experts streamed to the GPU over PCIe.
|
||||
|
||||
The full story, with measurements, bottlenecks and what comes next: **[docs/paper/Strata-Paper.pdf](paper/Strata-Paper.pdf)**.
|
||||
|
||||
---
|
||||
|
||||
## Credits and licenses
|
||||
|
||||
- Model: [Qwen/Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next) by the Qwen team; quantizations:
|
||||
[ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF).
|
||||
Swift 1.5: [ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF)
|
||||
by UkisAI. Their licenses apply to the weights.
|
||||
- [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp) (MIT): the i-quant formats, the GPU dot products and
|
||||
dequantizers transcribed in `src/kernels/cuda/iq_kernels.cu`, the CPU backend linked for the i-quant experts, the
|
||||
`mtmd` library behind the image encoder (`tools/vision/`), and `gguf-py` used by the tools. See
|
||||
`third_party/ggml/LICENSE`.
|
||||
- Ideas from [Splash](https://github.com/incoai/splash), [ninfer](https://github.com/Neroued/ninfer) and
|
||||
[HyperQwen](https://github.com/syv-ai/HyperQwen); references in the paper.
|
||||
- The web app's font: [Outfit](https://github.com/Outfitio/Outfit-Fonts) (SIL Open Font License 1.1, see
|
||||
`serve/web/fonts/OFL.txt`). Its Monitor tab started from @code-martin's dashboard idea (PR #22).
|
||||
@@ -36,6 +36,7 @@
|
||||
#include "strata/core/weights.hpp"
|
||||
|
||||
#include "strata/kernels/gr.hpp"
|
||||
#include "strata/kernels/kv_stream.hpp"
|
||||
#include "strata/kernels/ngram.hpp"
|
||||
#include "strata/kernels/ple.hpp"
|
||||
|
||||
@@ -206,10 +207,24 @@ struct QsaState {
|
||||
int8_t* v_q = nullptr;
|
||||
uint16_t* k_scale = nullptr;
|
||||
uint16_t* v_scale = nullptr;
|
||||
int32_t* page_table = nullptr; ///< (n_pages,) logical page -> physical page
|
||||
/// PR #21: Q4_0 KV with Walsh-Hadamard rotation (qsa_set_kv_q4, kv_q4.hpp): 144 B per cell and head
|
||||
bool kv_q4 = false;
|
||||
uint8_t* k_q4 = nullptr;
|
||||
uint8_t* v_q4 = nullptr;
|
||||
int32_t* page_table = nullptr; ///< (n_pages,) logical page -> physical page (-1: not resident, streamed)
|
||||
int64_t n_pages = 0;
|
||||
int64_t max_cells = 0;
|
||||
|
||||
/// KV STREAMING (docs/kv-streaming-design.md, `kv_stream.hpp`). `kv_mode` 0: every page in VRAM, identity
|
||||
/// table (n_slots == n_pages, no host copy). 1: streamed - the authoritative K/V in `host`, `n_slots` pages
|
||||
/// in VRAM, `map` resolves the selection's blocks on device. 2: a ring (the MTP drafter's window) - `n_slots`
|
||||
/// pages at `block % n_slots`, with the host copy for a resume. The pool pointers above point at the slots.
|
||||
int kv_mode = 0;
|
||||
int64_t n_slots = 0;
|
||||
strata::kernels::KvHostPools host;
|
||||
strata::kernels::KvStreamMap map;
|
||||
int64_t idx_pooled_rows = 0; ///< rows of `idx_pooled` (a ring, which has no indexer, keeps 2)
|
||||
|
||||
float* idx_tail = nullptr; ///< (idx_block - 1, idx_dim): the raw tail of the block being filled
|
||||
float* idx_dead = nullptr; ///< (idx_dim,): the spare slot's key, CONSTANT for the sequence
|
||||
float* idx_pooled = nullptr; ///< (max_cells/idx_block + 2, idx_dim)
|
||||
@@ -242,13 +257,35 @@ struct QsaState {
|
||||
/// Plan v0.3 P7: the RoPE cos/sin table (max_cells x n_rot/2 x 2 floats, 64 MiB at 262K) is identical in every
|
||||
/// QSA layer. `with_rope = false` sizes a state that borrows it; `share_rope` points `st` at another state's table
|
||||
/// instead of building a copy (the session builds it once, in the first QSA layer).
|
||||
uint64_t qsa_state_bytes(const ModelGeometry& g, int64_t max_cells, bool with_rope = true);
|
||||
uint64_t qsa_state_bytes(const ModelGeometry& g, int64_t max_cells, bool with_rope = true, int64_t ring_cells = 0);
|
||||
/// KV streaming: keep `cells` cells of each QSA layer in VRAM and the rest in pinned host memory (0: all in VRAM,
|
||||
/// the default). Set before sizing and initializing the session; a context that fits in `cells` is not streamed.
|
||||
/// Also puts the MTP drafter's K/V in a ring of its window (`ring_cells` of qsa_state_bytes/init; -1 forces a fully
|
||||
/// resident state).
|
||||
void qsa_set_kv_resident(int64_t cells);
|
||||
int64_t qsa_kv_resident();
|
||||
/// The fewest resident cells a streamed layer may have: one verify window's selections (8 queries x 2,051 cells
|
||||
/// in whole blocks) must fit at once, with room to spare.
|
||||
int64_t qsa_kv_resident_min();
|
||||
/// Pinned host bytes the streamed states hold (their host copies).
|
||||
uint64_t qsa_kv_host_bytes();
|
||||
/// Plan v0.3 P7: store K/V as INT8 with FP16 scales per 64 values (half the VRAM of FP16). Set before sizing and
|
||||
/// initializing the session; default off until gate G-C accepts it.
|
||||
void qsa_set_kv_int8(bool enabled);
|
||||
bool qsa_kv_int8();
|
||||
/// PR #21: store K/V as Q4_0 after a Hadamard rotation (`--kv q4_0`): 576 B per cell, vs 1,056 in INT8.
|
||||
void qsa_set_kv_q4(bool enabled);
|
||||
bool qsa_kv_q4();
|
||||
/// The state's KV format for the block-moving functions of kv_stream.hpp (kKvF16 / kKvInt8 / kKvQ4).
|
||||
inline int qsa_kv_format(const QsaState& st) {
|
||||
return st.kv_q4 ? strata::kernels::kKvQ4 : st.kv_int8 ? strata::kernels::kKvInt8 : strata::kernels::kKvF16;
|
||||
}
|
||||
uint64_t qsa_state_init(const ModelGeometry& g, int64_t max_cells, void* base, QsaState& st,
|
||||
const QsaState* share_rope = nullptr);
|
||||
const QsaState* share_rope = nullptr, int64_t ring_cells = 0);
|
||||
/// KV streaming: the pools a reader sees (the VRAM slots) and, when streamed, make the selection's blocks resident.
|
||||
strata::kernels::QsaAttnPools qsa_attn_pools(const QsaState& st);
|
||||
void qsa_kv_resolve(const QsaState& st, const ModelGeometry& g, const int32_t* ids, const int32_t* steps, int64_t n_q,
|
||||
int64_t cap, void* stream);
|
||||
/// Zeroes the pools AND the indexer, so a fresh sequence matches the reference's own `zeros()`. The KV pool
|
||||
/// matters even for cells that are never attended, because `kv_gather` reads whatever the selection names.
|
||||
void qsa_state_zero(const QsaState& st, const ModelGeometry& g, void* stream);
|
||||
|
||||
@@ -45,7 +45,14 @@ public:
|
||||
int64_t window = 32768);
|
||||
/// The prompt's length: prefill() skips the cells the attention window can never reach again.
|
||||
void set_prompt_len(int64_t n) { prompt_len_ = n; }
|
||||
/// At most this many drafts per round (below max_t - 1): a window longer than the MTP's comes from elsewhere.
|
||||
void set_max_drafts(int k) { max_drafts_ = k; }
|
||||
uint64_t vram_bytes() const { return vram_; }
|
||||
/// The draft layer's K/V state (read-only: --serve's STRATA_STATE_HASH check hashes it)
|
||||
const QsaState& kv_state() const { return st_; }
|
||||
/// KV streaming: refill the ring of the drafter's window from its host copy for a sequence that continues at
|
||||
/// `upto` (a conversation-cache resume). No-op unless the drafter's K/V is a ring.
|
||||
void kv_restore(int64_t upto);
|
||||
/// The main model's embedding and head, and the verify window's final residuals (T rows, hc*n_embd each).
|
||||
bool bind(const WeightTable& wt, const NativeHead* head, const float* window_R, std::string& err);
|
||||
|
||||
@@ -82,6 +89,7 @@ private:
|
||||
const NativeHead* head_ = nullptr;
|
||||
const float* window_R_ = nullptr;
|
||||
int max_t_ = 0;
|
||||
int max_drafts_ = 1 << 30;
|
||||
int64_t n_vocab_ = 0;
|
||||
uint64_t vram_ = 0;
|
||||
cudaStream_t cs_ = nullptr;
|
||||
|
||||
@@ -24,6 +24,7 @@
|
||||
#include "strata/core/expert_source.hpp"
|
||||
#include "strata/core/layer.hpp"
|
||||
#include "strata/core/session.hpp"
|
||||
#include "strata/kernels/sampler.hpp"
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
@@ -58,6 +59,21 @@ public:
|
||||
/// One window: `tokens[0..T)` at positions pos0.., the pool served per layer; `out[t]` = argmax after token t.
|
||||
/// The PLE rows are gathered here from `ss.ple_prev` and the tokens. Captures the T-token graph on first use.
|
||||
bool run(int T, const int32_t* tokens, int64_t pos0, PoolMultiFn pool, void* user, int32_t* out, std::string& err);
|
||||
/// The sampling the verify window's head applies (temperature / top_p / top_k / seed). Set per
|
||||
/// request; greedy by default. The sampling itself runs OUTSIDE the captured graph - its
|
||||
/// parameters would otherwise be baked forever - so this can change between requests freely.
|
||||
void set_sampling(const strata::kernels::SamplerParams& sp) {
|
||||
sampling_ = sp; // row t of a window at pos0 draws Philox(seed, pos0 + t): see run()
|
||||
}
|
||||
|
||||
/// The penalty-history row for `sampling_.penalty_last_n`: ONE row of `history_len` int32 slots, most
|
||||
/// recent token LAST, unused front slots -1 (the kernel reads only the tail window). Null disables the
|
||||
/// penalties entirely - the neutral run's sampling call is byte-for-byte what it was. The engine
|
||||
/// re-uploads the request's tail before every window; the pointer must stay alive across the request.
|
||||
void set_history(const int32_t* history, int history_len) {
|
||||
hist_d_ = history;
|
||||
hist_len_ = history_len;
|
||||
}
|
||||
|
||||
/// Keep the first `n_keep` (1..T) tokens of the last window; advances `ss.ple_prev` by them.
|
||||
bool commit(int n_keep, std::string& err);
|
||||
@@ -83,6 +99,14 @@ public:
|
||||
|
||||
private:
|
||||
bool capture(int T, std::string& err);
|
||||
strata::kernels::SamplerParams sampling_ = [] {
|
||||
strata::kernels::SamplerParams s;
|
||||
s.greedy = true;
|
||||
s.temperature = 0.0f;
|
||||
return s;
|
||||
}(); ///< greedy by default; per-request via set_sampling
|
||||
const int32_t* hist_d_ = nullptr; ///< penalty-history row (set_history); null = no penalties apply
|
||||
int hist_len_ = 0;
|
||||
bool capture_commit(std::string& err);
|
||||
bool record_window(int T, cudaStream_t cs, std::string& err);
|
||||
|
||||
|
||||
@@ -23,6 +23,9 @@ struct ExpertLayout {
|
||||
/// Plan v0.3 P6: per layer, the absolute offsets of the gate / up / down tensors in the model's shard 1, so
|
||||
/// the arena can be filled from the GGUF itself when the pack has no experts.bin (3 x n_layers, 0 = unknown).
|
||||
std::vector<uint64_t> gguf_off;
|
||||
/// Per layer, the GGUF file (a name beside the --native shard) that holds its experts when the model's
|
||||
/// shards split the layers (Swift's GGUFs: layers 13-47 in shard 2). Empty = the --native shard itself.
|
||||
std::vector<std::string> gguf_file;
|
||||
uint64_t max_blob = BLOB;
|
||||
uint64_t total = 0; ///< experts.bin size
|
||||
|
||||
|
||||
@@ -23,7 +23,10 @@
|
||||
#include "strata/kernels/cpu/native_expert.hpp"
|
||||
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <condition_variable>
|
||||
#include <cstdint>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
@@ -136,10 +139,19 @@ public:
|
||||
repark = ms_repark_;
|
||||
}
|
||||
|
||||
/// **A PARKED WORKER SPINS FOR THIS LONG, THEN SLEEPS.** The park is a `_mm_pause` spin because a layer's
|
||||
/// batches are microseconds apart and a wake-up from the OS costs more than that. But a spin that never ends
|
||||
/// keeps every worker's core at 100% while the engine waits for a request - issue #4, "CPU 50% even when
|
||||
/// doing nothing" (7 of the 5700X's 16 threads). Inside a request the gaps between batches are far below
|
||||
/// this, so the token path still never sleeps; between requests the workers block on `sleep_cv_`.
|
||||
static constexpr std::chrono::milliseconds kSpinBeforeSleep{20};
|
||||
|
||||
private:
|
||||
void worker(int id);
|
||||
void drain(int id, ExpertScratch& scratch);
|
||||
void run_phase(int mode, int n_tasks);
|
||||
/// Bump `epoch_`, and wake the workers that went to sleep. Every publish goes through here.
|
||||
void publish();
|
||||
|
||||
int n_ = 0;
|
||||
bool host_works_ = true;
|
||||
@@ -169,6 +181,11 @@ private:
|
||||
alignas(64) std::atomic<uint32_t> parked_{0};
|
||||
alignas(64) std::atomic<uint32_t> epoch_{0};
|
||||
alignas(64) std::atomic<bool> stop_{false};
|
||||
// The sleep after `kSpinBeforeSleep`. `sleepers_` is how `publish` knows whether anyone needs waking, so the
|
||||
// token path pays one uncontended load per publish and never takes the mutex while the workers spin.
|
||||
alignas(64) std::atomic<uint32_t> sleepers_{0};
|
||||
std::mutex sleep_mu_;
|
||||
std::condition_variable sleep_cv_;
|
||||
std::vector<std::thread> threads_;
|
||||
std::vector<ExpertScratch> scratch_; // one per worker: no allocation, no false sharing of the hot data
|
||||
// run_split state: mode 0 = whole experts, 1 = gate/up row parts, 2 = down row parts
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
// include/strata/kernels/cvec.hpp - a control vector on the residual stream: the engine's side of llama.cpp's
|
||||
// `llama_adapter_cvec` with the `--cvec-mode` / `--cvec-dir` extension of the `experimental-speed-projection`
|
||||
// package (its `02-cvec-projection-mode.patch`, and `01-qwen4exp-cvec-hooks.patch` for WHERE it applies).
|
||||
//
|
||||
// After layer l's FFN write - llama.cpp's `build_cvec(res_hc, il)` right after the layer's second
|
||||
// `build_hc_combine` - every one of the hc residual streams h of every token becomes
|
||||
//
|
||||
// project: h <- h - s_l (h . v_l) v_l v_l = d / |d|, s_l = |d|, d = the scaled direction
|
||||
// add: h <- h + d llama.cpp's stock additive control vector
|
||||
//
|
||||
// for l in [first, last]. `d` is the GGUF's `direction.<src>` times the file's scale (summed over files), with
|
||||
// src = l (per-layer) or one fixed layer (single:L, project mode only), exactly as llama.cpp's loader places it;
|
||||
// layer 0 has no direction. Off unless a vector is loaded (--control-vector-scaled); a loaded one is switched
|
||||
// per request through a device flag, so the captured graphs are the same either way. With the flag off the
|
||||
// result is bit-identical to the engine without a vector: the kernel then only applies the pending residual
|
||||
// write, with the fused read's own arithmetic.
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace strata::kernels {
|
||||
|
||||
struct Cvec {
|
||||
const float* dir = nullptr; ///< device, n_layers * n_embd: project = the unit v_l, add = d_l; zero rows elsewhere
|
||||
const float* s = nullptr; ///< device, n_layers: project = s_l, add = 1; 0 = the layer is not steered
|
||||
const int* on = nullptr; ///< device int: 0 = this request runs the stock model
|
||||
int mode = 0; ///< 0 = project, 1 = add
|
||||
int first = 0, last = -1; ///< the steered layers, inclusive
|
||||
int64_t n_embd = 0, hc = 0;
|
||||
bool loaded() const { return dir != nullptr; }
|
||||
/// Layer l's FFN write is followed by the vector (with a real direction there). Decided at load time, never
|
||||
/// per request: it changes where the residual write happens, so the graphs depend on it.
|
||||
bool covers(int64_t l) const { return loaded() && l >= first && l <= last && l < (int64_t) steered.size() && steered[(size_t) l]; }
|
||||
std::vector<bool> steered; ///< host copy of s_l != 0
|
||||
};
|
||||
|
||||
/// The loaded vector (empty until `cvec_upload`).
|
||||
const Cvec& cvec();
|
||||
|
||||
/// Upload a vector built by the loader: `dir` is n_layers * n_embd, `s` n_layers (see `Cvec`). Starts ON.
|
||||
bool cvec_upload(const std::vector<float>& dir, const std::vector<float>& s, int mode, int first, int last,
|
||||
int64_t n_embd, int64_t hc, std::string& err);
|
||||
|
||||
/// The per-request switch. Synchronizes the device when it changes, so call it between requests.
|
||||
void cvec_set_enabled(bool on);
|
||||
bool cvec_enabled();
|
||||
|
||||
/// Layer `layer`'s vector on T tokens' residual stacks (`R + t * r_ld`, hc streams of n_embd). With `write`, the
|
||||
/// pending FFN write `R += bo * 2 sigmoid(inj / hc)` (the fused read's arithmetic) is applied first, for callers
|
||||
/// whose writes are folded into the next layer's read; without it, R must already hold the layer's output.
|
||||
void cvec_apply(float* R, int64_t layer, int64_t T, int64_t r_ld, const float* bo, int64_t bo_ld, const float* inj,
|
||||
int64_t inj_ld, bool write, void* stream);
|
||||
|
||||
} // namespace strata::kernels
|
||||
@@ -0,0 +1,61 @@
|
||||
// include/strata/kernels/kv_q4.hpp - Q4_0 KV storage with Walsh-Hadamard rotation for the QSA layers (`--kv q4_0`).
|
||||
//
|
||||
// From PR #21 (code-martin). K and V are rotated by the orthonormal 256-point Hadamard matrix H before they are
|
||||
// quantized to ggml's q4_0 (32 values per block: an fp16 scale + 16 bytes of 4-bit codes, 144 B per head per cell,
|
||||
// 576 B per cell for K and V of both heads, vs 1,056 B in INT8). The rotation spreads a head's outlier channels
|
||||
// over all 256 dimensions, which is what makes 4 bits usable. The query is rotated the same way, so
|
||||
// <Hq, Hk> = <q, k> and the scores are unchanged, and the attention output (a mix of rotated values) is rotated
|
||||
// back with H (self-inverse). What is lossy is the 4-bit rounding itself: measured, not assumed, in
|
||||
// bench/results/2026-09-27-kv-q4.
|
||||
//
|
||||
// With KV streaming (--kv-resident) the codes live in the host copy and the resident slots like INT8's (KvHostPools
|
||||
// k_q4/v_q4, the same block granule), so both options combine.
|
||||
#pragma once
|
||||
|
||||
#include "strata/kernels/qsa.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace strata::kernels {
|
||||
|
||||
inline constexpr int QK4_0 = 32;
|
||||
|
||||
#pragma pack(push, 1)
|
||||
struct block_q4_0 {
|
||||
uint16_t d; // scale (fp16 bits)
|
||||
uint8_t qs[QK4_0 / 2]; // 32 4-bit codes: element j in the low nibble of qs[j], j + 16 in the high one
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
static_assert(sizeof(block_q4_0) == 18, "block_q4_0 must be 18 bytes");
|
||||
|
||||
/// Bytes per cell and KV head: 8 blocks of 32 for head_dim 256 -> 144.
|
||||
inline uint64_t kv_q4_bytes_per_head(int head_dim) { return (uint64_t) (head_dim / QK4_0) * sizeof(block_q4_0); }
|
||||
|
||||
/// Bytes per cell (one token, one layer): K and V of every KV head.
|
||||
inline uint64_t kv_q4_bytes_per_cell(const QsaShapes& s) {
|
||||
return (uint64_t) s.n_head_kv * kv_q4_bytes_per_head((int) s.head_dim) * 2;
|
||||
}
|
||||
|
||||
/// Orthonormal Fast Walsh-Hadamard Transform of rows of 256 floats (scale 1/16): its own inverse.
|
||||
void fwht256_cuda(const float* src, float* dst, int64_t n_rows, void* stream);
|
||||
inline void fwht256_inplace_cuda(float* data, int64_t n_rows, void* stream) { fwht256_cuda(data, data, n_rows, stream); }
|
||||
|
||||
/// Append the (already rotated) cell at step[kStepPos]. With a host copy (KV streaming) it is written there too,
|
||||
/// and to VRAM only if its block is resident.
|
||||
void kv_append_q4_step(uint8_t* k_q4, uint8_t* v_q4, const int32_t* page_table, const int32_t* step,
|
||||
const float* kcur, const float* vcur, const QsaShapes& s, void* stream,
|
||||
const KvHostPools* host = nullptr);
|
||||
|
||||
/// The prompt path: T consecutive (rotated) cells from pos0, K/V [T, n_head_kv, 256]; also into `stage` (identity
|
||||
/// layout, the one-layer staging pool of a streamed session) when given.
|
||||
void kv_append_q4(uint8_t* k_q4, uint8_t* v_q4, const int32_t* page_table, int64_t pos0, int64_t T, const float* K,
|
||||
const float* V, const QsaShapes& s, void* stream, const KvHostPools* host = nullptr,
|
||||
const KvHostPools* stage = nullptr);
|
||||
|
||||
/// Gather step[kStepWidth] cells named by `ids` into FP16 scratch [id][kv_head][head_dim] (still rotated).
|
||||
void kv_gather_q4_step(const uint8_t* k_q4, const uint8_t* v_q4, const int32_t* page_table, const int32_t* ids,
|
||||
const int32_t* step, int64_t max_ids, const QsaShapes& s, uint16_t* k_scratch,
|
||||
uint16_t* v_scratch, void* stream);
|
||||
|
||||
} // namespace strata::kernels
|
||||
@@ -12,6 +12,7 @@
|
||||
// the FP16 pools: codes `[page][kv_head][page_size][head_dim]`, scales `[page][kv_head][page_size][head_dim/64]`.
|
||||
#pragma once
|
||||
|
||||
#include "strata/kernels/kv_stream.hpp"
|
||||
#include "strata/kernels/qsa.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
@@ -25,9 +26,11 @@ inline uint64_t kv_q8_bytes_per_cell(const QsaShapes& s) {
|
||||
return (uint64_t) s.n_head_kv * s.head_dim * 2 + (uint64_t) s.n_head_kv * (s.head_dim / KV_Q8_GROUP) * 2 * 2;
|
||||
}
|
||||
|
||||
/// Append the cell at step[kStepPos] (graph-capturable: position and page come from device memory).
|
||||
/// Append the cell at step[kStepPos] (graph-capturable: position and page come from device memory). With a host
|
||||
/// copy (KV streaming, `kv_stream.hpp`) the cell is written there too, and to VRAM only if its block is resident.
|
||||
void kv_append_q8_step(int8_t* k_q, int8_t* v_q, uint16_t* k_scale, uint16_t* v_scale, const int32_t* page_table,
|
||||
const int32_t* step, const float* kcur, const float* vcur, const QsaShapes& s, void* stream);
|
||||
const int32_t* step, const float* kcur, const float* vcur, const QsaShapes& s, void* stream,
|
||||
const KvHostPools* host = nullptr);
|
||||
|
||||
/// Gather step[kStepWidth] cells named by `ids` into FP16 scratch `[id][kv_head][head_dim]`; the grid is sized by
|
||||
/// `max_ids` (capacity), the kernel reads the real count from `step`.
|
||||
|
||||
@@ -0,0 +1,98 @@
|
||||
// include/strata/kernels/kv_stream.hpp - KV streaming for the QSA layers (docs/kv-streaming-design.md).
|
||||
//
|
||||
// A streamed QSA layer keeps its AUTHORITATIVE K/V in pinned, device-mapped host memory, laid out exactly as a
|
||||
// fully resident pool with the identity page table would be. VRAM holds a pool of `n_slots` pages (one page =
|
||||
// `page_size` = 4 cells = one indexer block, all KV heads, K and V: 4,224 B in int8), and the page table becomes a
|
||||
// RESIDENCY MAP: `page_table[block]` is the slot holding that block, or -1.
|
||||
//
|
||||
// Every reader (`qsa_decode_attn_*`, `kv_gather_*`) is unchanged: it goes through the page table as before. What
|
||||
// changes is that after the selection and before the attention, `kv_stream_resolve` makes every block the
|
||||
// selection names resident - on device, inside the captured graphs:
|
||||
// 1. one block of 1,024 threads walks the selected ids: a resident block gets this call's epoch and its clock
|
||||
// reference bit, a missing block is claimed once (page_table -1 -> -2) into a miss list;
|
||||
// 2. the same block picks one victim slot per miss with a CLOCK sweep (second chance) that never takes a slot
|
||||
// this call uses, re-points the page table (old block -> -1, new block -> slot);
|
||||
// 3. a copy kernel reads the missed blocks from the host copy (zero-copy, over PCIe) into their slots.
|
||||
// Writers (`kv_append_*`) write the host copy always, and the slot only if the block is resident, so the slots
|
||||
// never go stale and nothing needs invalidating - not after a rejected draft, not on a conversation-cache resume.
|
||||
//
|
||||
// A RING (the MTP drafter, which only ever reads its last `window` cells) uses the same host copy with a static
|
||||
// table `block -> block % n_slots` and no resolve: the ring is refilled from the host copy on a resume.
|
||||
#pragma once
|
||||
|
||||
#include "strata/kernels/qsa.hpp"
|
||||
#include "strata/kernels/qsa_decode_attn.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace strata::kernels {
|
||||
|
||||
/// The host copy of one layer's K/V: device-mapped pointers (UVA) into pinned memory, identity layout
|
||||
/// `[block][kv_head][page_size][head_dim]`. All null when the layer is fully resident.
|
||||
struct KvHostPools {
|
||||
uint16_t* k_pool = nullptr; ///< fp16 mode
|
||||
uint16_t* v_pool = nullptr;
|
||||
int8_t* k_q = nullptr; ///< int8 mode: codes
|
||||
int8_t* v_q = nullptr;
|
||||
uint16_t* k_scale = nullptr; ///< int8 mode: fp16 scale per 64 values
|
||||
uint16_t* v_scale = nullptr;
|
||||
uint8_t* k_q4 = nullptr; ///< q4_0 mode (kv_q4.hpp): block_q4_0 codes, 144 B per cell and head
|
||||
uint8_t* v_q4 = nullptr;
|
||||
bool present() const { return k_pool != nullptr || k_q != nullptr || k_q4 != nullptr; }
|
||||
};
|
||||
|
||||
/// The KV storage format, for the functions below that move whole blocks (`fmt`): fp16, int8 (+ scales), q4_0.
|
||||
/// (A bool `int8` argument still reads as kKvF16 / kKvInt8.)
|
||||
enum KvFormat : int { kKvF16 = 0, kKvInt8 = 1, kKvQ4 = 2 };
|
||||
|
||||
/// The residency map of a streamed layer, all device memory at fixed addresses (the graphs bake them in).
|
||||
struct KvStreamMap {
|
||||
int32_t* page_table = nullptr; ///< (n_blocks,) block -> slot, or -1
|
||||
int32_t* slot_block = nullptr; ///< (n_slots,) slot -> block, or -1
|
||||
int32_t* slot_stamp = nullptr; ///< (n_slots,) the resolve epoch that last used the slot
|
||||
int32_t* slot_ref = nullptr; ///< (n_slots,) clock reference bit
|
||||
int32_t* ctl = nullptr; ///< kKvCtlInts: epoch, hand, misses of the last call, overflow, u64 counters
|
||||
int32_t* miss_block = nullptr; ///< (n_slots,)
|
||||
int32_t* miss_slot = nullptr; ///< (n_slots,)
|
||||
int64_t n_blocks = 0;
|
||||
int64_t n_slots = 0;
|
||||
};
|
||||
|
||||
inline constexpr int kKvCtlInts = 16; ///< [0] epoch [1] hand [2] misses [3] overflow; u64 at [4] misses, [6] lookups, [8] calls
|
||||
/// Bytes of the map's arrays besides the page table (which the state already has): 5 per-slot ints + ctl.
|
||||
inline uint64_t kv_stream_map_bytes(int64_t n_slots) { return (uint64_t) n_slots * 4 * 5 + kKvCtlInts * 4; }
|
||||
|
||||
/// Every block evicted: page table all -1, slots free, counters zero.
|
||||
void kv_stream_reset(const KvStreamMap& m, void* stream);
|
||||
|
||||
/// Make every block named by the selections of `n_q` queries resident (ids [n_q][cap], width from
|
||||
/// steps[q * kStepCount + kStepWidth]). Capturable. `n_slots` must hold the distinct blocks of one call
|
||||
/// (n_q x (cap / page_size + 2)); a call that cannot sets ctl[3] (see `kv_stream_counters`).
|
||||
void kv_stream_resolve(const KvStreamMap& m, const QsaAttnPools& slots, const KvHostPools& host, int fmt,
|
||||
const int32_t* ids, const int32_t* steps, int64_t n_q, int64_t cap, const QsaShapes& s,
|
||||
void* stream);
|
||||
|
||||
/// The static ring table `block -> block % n_slots`.
|
||||
void kv_ring_table(int32_t* page_table, int64_t n_blocks, int64_t n_slots, void* stream);
|
||||
|
||||
/// Copy blocks [b0, b1) of the host copy into the pool pages `page_table` names (host-side table `phys(b)`
|
||||
/// computed as `b % n_slots`: the ring restore). Not capturable.
|
||||
void kv_ring_restore(const QsaAttnPools& slots, const KvHostPools& host, int fmt, int64_t b0, int64_t b1,
|
||||
int64_t n_slots, const QsaShapes& s, void* stream);
|
||||
|
||||
/// Copy the first `n_blocks` blocks of the host copy into a fully resident (identity-layout) pool: the prompt
|
||||
/// path's staging of one layer. Not capturable (DMA).
|
||||
void kv_stage_from_host(const QsaAttnPools& stage, const KvHostPools& host, int fmt, int64_t n_blocks,
|
||||
const QsaShapes& s, void* stream);
|
||||
|
||||
struct KvStreamCounters {
|
||||
uint64_t misses = 0, lookups = 0, calls = 0;
|
||||
bool overflow = false;
|
||||
};
|
||||
/// Synchronous read of the counters (debug and the end-of-request summary).
|
||||
KvStreamCounters kv_stream_counters(const KvStreamMap& m);
|
||||
|
||||
/// Bytes of one block (page) of K and V together.
|
||||
uint64_t kv_block_bytes(const QsaShapes& s, int fmt);
|
||||
|
||||
} // namespace strata::kernels
|
||||
@@ -110,7 +110,9 @@ inline QsaShapes qsa_real_shapes() {
|
||||
QsaShapes s;
|
||||
s.n_head = 24; s.n_head_kv = 2; s.head_dim = 256; s.n_rot = 64;
|
||||
s.idx_n_head = 4; s.idx_dim = 128; s.idx_block = 4; s.idx_top_k = 2048;
|
||||
s.page_size = 512;
|
||||
// one page = one indexer block (4 cells): the granule KV streaming keeps resident (kv_stream.hpp). The readers
|
||||
// resolve a row per cell anyway, so the page size costs them nothing (measured: identical output and speed).
|
||||
s.page_size = 4;
|
||||
return s;
|
||||
}
|
||||
|
||||
@@ -353,8 +355,12 @@ void qsa_attend_step(const float* q, const uint16_t* k_scratch, const uint16_t*
|
||||
const int32_t* step, int64_t max_ids, const QsaShapes& s, float* attn, float* weights,
|
||||
void* stream);
|
||||
|
||||
/// The cell's position comes from `step`, so this is the form a graph may contain.
|
||||
struct KvHostPools; // kv_stream.hpp
|
||||
|
||||
/// The cell's position comes from `step`, so this is the form a graph may contain. With a host copy (KV streaming)
|
||||
/// the cell is written there too, and to VRAM only if its block is resident.
|
||||
void kv_append_step(uint16_t* k_pool, uint16_t* v_pool, const int32_t* page_table, const int32_t* step,
|
||||
const float* kcur, const float* vcur, const QsaShapes& s, void* stream);
|
||||
const float* kcur, const float* vcur, const QsaShapes& s, void* stream,
|
||||
const KvHostPools* host = nullptr);
|
||||
|
||||
} // namespace strata::kernels
|
||||
@@ -27,6 +27,8 @@ struct QsaAttnPools {
|
||||
const int8_t* v_q = nullptr;
|
||||
const uint16_t* k_scale = nullptr; ///< fp16 [page][kv_head][page_size][head_dim / 64]
|
||||
const uint16_t* v_scale = nullptr;
|
||||
const uint8_t* k_q4 = nullptr; ///< q4_0 block_q4_0 [page][kv_head][page_size][head_dim / 32 * 18]
|
||||
const uint8_t* v_q4 = nullptr;
|
||||
const int32_t* page_table = nullptr;
|
||||
};
|
||||
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
// include/strata/kernels/sampler.hpp - the sampler chain, host-callable (P2.S2).
|
||||
//
|
||||
// penalties -> top_k -> top_p -> temperature -> pick
|
||||
// penalties -> top_k -> min_p -> top_p -> temperature -> penalties -> pick
|
||||
//
|
||||
// The ORDER is specified in docs/sampling.md, transcribed from llama.cpp's own chain. Two facts there are
|
||||
// easy to get backwards: temperature comes AFTER the truncation filters, and penalties come AFTER temperature.
|
||||
//
|
||||
// PENALTIES ARE NOT IMPLEMENTED YET: they need the token history, which is not in this signature, so a caller
|
||||
// passing a non-zero `penalty_last_n` gets a loud failure rather than a silently unpenalised sample.
|
||||
// The ORDER is specified in docs/sampling.md, transcribed from llama.cpp's own chain. Three facts there are
|
||||
// easy to get backwards: temperature comes AFTER the truncation filters, penalties come AFTER temperature as
|
||||
// well as before the selection, and min_p cuts BEFORE top_p (both on the pre-temperature logits).
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
@@ -16,6 +14,7 @@ namespace strata::kernels {
|
||||
struct SamplerParams {
|
||||
int top_k = 20; // 0 disables the filter
|
||||
float top_p = 0.95f; // 1.0 disables the filter
|
||||
float min_p = 0.0f; // 0 disables; keeps tokens with p >= min_p * p_max (a prefix of the top_k list)
|
||||
float temperature = 1.0f; // <= 0 means greedy
|
||||
int min_keep = 1; // top_p keeps at least this many
|
||||
int penalty_last_n = 0; // 0 disables; the window over `history` to count occurrences in
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
// the kernel walks the chunk's tokens in order inside one launch.
|
||||
#pragma once
|
||||
|
||||
#include "strata/kernels/kv_stream.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace strata::prefill {
|
||||
@@ -63,11 +65,14 @@ void gate_attn(const float* attn, const float* q_full, uint16_t* out16, int64_t
|
||||
/// K, V: [T, 2, 256].
|
||||
void kv_append(const float* K, const float* V, int64_t T, int64_t pos0, const int32_t* page_table, int64_t page_size,
|
||||
uint16_t* k_pool, uint16_t* v_pool, int8_t* k_q, int8_t* v_q, uint16_t* k_scale, uint16_t* v_scale,
|
||||
void* stream);
|
||||
void* stream, const strata::kernels::KvHostPools* host = nullptr,
|
||||
const strata::kernels::KvHostPools* stage = nullptr);
|
||||
|
||||
/// fp32 -> fp16 bits and fp32 -> bf16, n elements (the two activation images of the prompt GEMMs).
|
||||
void to_f16(const float* x, uint16_t* y, int64_t n, void* stream);
|
||||
void to_bf16(const float* x, uint16_t* y, int64_t n, void* stream);
|
||||
/// y = fp32(fp16(x)): what an FP16 store of x would read back (the FP16 indexer-key experiment)
|
||||
void round_f16(const float* x, float* y, int64_t n, void* stream);
|
||||
/// Expert blob -> FP16 (Q2_0 values are exact in FP16).
|
||||
void blob_dequant_f16(const uint8_t* blob, uint16_t* gu16, uint16_t* down16, void* stream);
|
||||
|
||||
|
||||
@@ -62,6 +62,9 @@ public:
|
||||
/// K/V from them. The prefill stream is synchronized before the call.
|
||||
std::function<bool(const float* R_rows, int64_t T, int64_t pos0, std::string& err)> on_chunk;
|
||||
|
||||
/// Checked before every chunk: true stops the prompt early (`run` returns false with err "cancelled").
|
||||
std::function<bool()> should_stop;
|
||||
|
||||
/// The vision path: HOST rows (n_embd floats) indexed by absolute position, read in place of the token
|
||||
/// embedding where non-null (an image's <|image_pad|> cells). Null (default): every position embeds its token.
|
||||
const float* const* embd_rows = nullptr;
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
// include/strata/spec/draft_policy.hpp - per verify round: the MTP's window, or a lookup (suffix) window?
|
||||
//
|
||||
// The suffix drafter (prompt lookup) proposes the tokens that followed an earlier repeat of the context. Taken
|
||||
// whenever it proposes more than the MTP, it lost 2-8% on ordinary text: a long lookup window costs much more to
|
||||
// verify than the MTP's usual 3-4 tokens, and it is only worth that when enough of it is accepted. llama.cpp's
|
||||
// lookup decoding answers the same problem with confidence thresholds on its n-gram statistics; here the policy
|
||||
// learns both sides online and compares expected committed tokens per millisecond:
|
||||
//
|
||||
// MTP E = the mean tokens a window of that size has committed (EMA), at the measured cost of that size
|
||||
// lookup E(k) = 1 + q + q^2 + ... + q^k for k <= the proposal, q = the acceptance rate of lookup drafts whose
|
||||
// match was about as long (4 buckets of match length, decayed counts), at the measured cost of k + 1
|
||||
//
|
||||
// and takes the lookup window only when its best E/cost beats the MTP's by `margin`. Costs are the measured round
|
||||
// times per window size (EMA; sizes not seen yet are scaled from seen ones by a prior shape), so the policy adapts
|
||||
// to the machine and the context length. It only chooses which drafts to verify: the output is unchanged.
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
|
||||
namespace strata::spec {
|
||||
|
||||
class DraftPolicy {
|
||||
public:
|
||||
static constexpr int kMaxT = 8;
|
||||
static constexpr int kBuckets = 4;
|
||||
|
||||
explicit DraftPolicy(int max_t, double margin = 0.03);
|
||||
|
||||
struct Pick {
|
||||
bool lookup = false;
|
||||
int t = 1; // window size (1 + drafts)
|
||||
};
|
||||
/// `t_mtp`: the MTP's window; `lookup_k`: the lookup proposal's length (0 = none); `match`: its match length.
|
||||
Pick choose(int t_mtp, int lookup_k, int match) const;
|
||||
/// After the round: the window it used, the drafts accepted, and the round's time (verify + commit + draft).
|
||||
void observe(bool lookup, int t, int accepted, int match, double round_ms);
|
||||
|
||||
double lookup_rate(int match) const; // current q for a match length
|
||||
double cost_ms(int t) const; // measured or scaled round time of a window of t tokens
|
||||
|
||||
private:
|
||||
static int bucket(int match);
|
||||
double mtp_tokens(int t) const;
|
||||
|
||||
int max_t_;
|
||||
double margin_;
|
||||
std::array<double, kMaxT + 1> cost_{}, cost_n_{}; // round ms by window size
|
||||
std::array<double, kMaxT + 1> mtp_tok_{}, mtp_n_{}; // tokens committed by MTP windows of that size
|
||||
std::array<double, kBuckets> ok_{}, bad_{}; // lookup drafts accepted / windows cut short, decayed
|
||||
};
|
||||
|
||||
} // namespace strata::spec
|
||||
+137
-2
@@ -270,11 +270,127 @@ class OutputParser:
|
||||
"""Incremental parser of the model's text. Feed deltas; get events. A tag split across deltas is held back
|
||||
until it is complete, so clients never see `<tool_` or `</thi`."""
|
||||
|
||||
def __init__(self, thinking: bool = True, tools: list[dict] | None = None):
|
||||
def __init__(self, thinking: bool = True, tools: list[dict] | None = None, stream_tools: bool = False):
|
||||
self.state = "reasoning" if thinking else "content"
|
||||
self.buf = ""
|
||||
self.lead = False
|
||||
self.schemas = {t.get("name"): t for t in tools or []}
|
||||
# stream_tools: a tool call is also reported while it is being written - "tool_start" (its name and id) as
|
||||
# soon as the name is known, then "tool_args" pieces of its JSON arguments (string parameters character by
|
||||
# character; other types whole, once complete) - before the final "tool_call". Without it, a client sees
|
||||
# nothing until the call is complete, which for a large file write can be many minutes.
|
||||
self.stream_tools = stream_tools
|
||||
self._reset_scan()
|
||||
|
||||
def _reset_scan(self):
|
||||
self.sp = 0 # how much of self.buf (the call body) the scanner has consumed
|
||||
self.ss = "name" # name -> between -> str|raw -> ... -> done
|
||||
self.scall = None # the ToolCall being streamed (its id is reused by the final event)
|
||||
self.sfirst = True
|
||||
self.sval_started = False
|
||||
self.sdeclared = {}
|
||||
|
||||
def _scan(self) -> list[Event]:
|
||||
"""Advance the streaming view of the call body in self.buf (see stream_tools)."""
|
||||
out = []
|
||||
|
||||
def args(s):
|
||||
if s:
|
||||
out.append(Event("tool_args", s, call=self.scall))
|
||||
while True:
|
||||
rest = self.buf[self.sp:]
|
||||
if self.ss == "name":
|
||||
a = rest.find("<function=")
|
||||
b = rest.find(">", a + 10) if a >= 0 else -1
|
||||
if b < 0:
|
||||
return out
|
||||
name = rest[a + 10:b]
|
||||
self.scall = ToolCall(name=name, arguments={})
|
||||
props = ((self.schemas.get(name) or {}).get("parameters") or {}).get("properties") or {}
|
||||
self.sdeclared = {k: (v or {}).get("type") for k, v in props.items()}
|
||||
out.append(Event("tool_start", call=self.scall))
|
||||
args("{")
|
||||
self.sp += b + 1
|
||||
self.ss = "between"
|
||||
elif self.ss == "between":
|
||||
stripped = rest.lstrip()
|
||||
self.sp += len(rest) - len(stripped)
|
||||
if stripped.startswith("<parameter="):
|
||||
b = stripped.find(">")
|
||||
if b < 0:
|
||||
return out
|
||||
pname = stripped[11:b]
|
||||
args(("" if self.sfirst else ",") + json.dumps(pname) + ":")
|
||||
self.sfirst = False
|
||||
self.sp += b + 1
|
||||
if self.sdeclared.get(pname) == "string":
|
||||
args('"')
|
||||
self.ss, self.sval_started = "str", False
|
||||
else:
|
||||
self.ss = "raw"
|
||||
elif stripped.startswith("</function>"):
|
||||
args("}")
|
||||
self.sp += len("</function>")
|
||||
self.ss = "done"
|
||||
else:
|
||||
return out # a tag still arriving (or trailing text): wait
|
||||
elif self.ss == "str":
|
||||
if not self.sval_started:
|
||||
if not rest:
|
||||
return out
|
||||
if rest[0] == "\n": # the value's leading newline is not part of it
|
||||
self.sp += 1
|
||||
rest = rest[1:]
|
||||
self.sval_started = True
|
||||
end = rest.find("</parameter>")
|
||||
if end >= 0:
|
||||
value = rest[:end]
|
||||
if value.endswith("\n"):
|
||||
value = value[:-1]
|
||||
args(json.dumps(value)[1:-1] + '"')
|
||||
self.sp += end + len("</parameter>")
|
||||
self.ss = "between"
|
||||
continue
|
||||
safe = len(rest) - self._hold(rest, ("</parameter>",))
|
||||
if safe > 0 and rest[safe - 1] == "\n": # may be the trailing newline before </parameter>
|
||||
safe -= 1
|
||||
if safe > 0:
|
||||
args(json.dumps(rest[:safe])[1:-1])
|
||||
self.sp += safe
|
||||
return out
|
||||
elif self.ss == "raw":
|
||||
end = rest.find("</parameter>")
|
||||
if end < 0:
|
||||
return out
|
||||
value = rest[:end]
|
||||
if value.startswith("\n"):
|
||||
value = value[1:]
|
||||
if value.endswith("\n"):
|
||||
value = value[:-1]
|
||||
try:
|
||||
v = json.loads(value)
|
||||
except ValueError:
|
||||
v = value
|
||||
args(json.dumps(v, ensure_ascii=False))
|
||||
self.sp += end + len("</parameter>")
|
||||
self.ss = "between"
|
||||
else:
|
||||
return out
|
||||
|
||||
def _close_scan(self) -> list[Event]:
|
||||
"""A streamed call that ended without a clean </function>: close its JSON so clients can still parse it."""
|
||||
out = []
|
||||
if self.scall is None or self.ss == "done":
|
||||
return out
|
||||
tail = ""
|
||||
if self.ss == "str":
|
||||
tail += '"'
|
||||
elif self.ss == "raw":
|
||||
tail += json.dumps(self.buf[self.sp:].strip("\n"))
|
||||
tail += "}"
|
||||
out.append(Event("tool_args", tail, call=self.scall))
|
||||
self.ss = "done"
|
||||
return out
|
||||
|
||||
def _hold(self, text: str, tags: tuple[str, ...]) -> int:
|
||||
"""Length of the longest suffix of `text` that is a proper prefix of one of `tags`."""
|
||||
@@ -325,17 +441,36 @@ class OutputParser:
|
||||
self.state = "call"
|
||||
else:
|
||||
i = self.buf.find(CALL_END)
|
||||
if self.stream_tools:
|
||||
if i >= 0:
|
||||
whole, self.buf = self.buf, self.buf[:i] # scan only the body
|
||||
out += self._scan()
|
||||
out += self._close_scan()
|
||||
self.buf = whole
|
||||
else:
|
||||
out += self._scan()
|
||||
if i < 0:
|
||||
return out
|
||||
body = self.buf[:i]
|
||||
self.buf = self.buf[i + len(CALL_END):]
|
||||
name = body.strip()[len("<function="):].split(">", 1)[0]
|
||||
out.append(Event("tool_call", call=parse_tool_call(body, self.schemas.get(name))))
|
||||
call = parse_tool_call(body, self.schemas.get(name))
|
||||
if self.scall is not None:
|
||||
call.id = self.scall.id
|
||||
out.append(Event("tool_call", call=call))
|
||||
self._reset_scan()
|
||||
self.state, self.lead = "content", True
|
||||
|
||||
def finish(self) -> list[Event]:
|
||||
"""End of generation: flush whatever is held (an unterminated tool call is returned as content)."""
|
||||
out = []
|
||||
if self.state == "call" and self.stream_tools and self.scall is not None:
|
||||
out += self._scan() # the output ended inside a call that was already announced
|
||||
out += self._close_scan()
|
||||
out.append(Event("tool_call", call=self.scall))
|
||||
self.buf = ""
|
||||
self._reset_scan()
|
||||
return out
|
||||
if self.buf:
|
||||
kind = {"reasoning": "reasoning", "content": "content"}.get(self.state, "content")
|
||||
text = self.buf if self.state != "call" else CALL_START + self.buf
|
||||
|
||||
@@ -1,152 +0,0 @@
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Strata</title>
|
||||
<style>
|
||||
:root { --bg:#f6f7f9; --card:#fff; --fg:#1b1f24; --mute:#667085; --line:#e3e6ea; --acc:#2f6fed; --me:#e9f0ff; --ok:#1a7f37; }
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root { --bg:#111418; --card:#1a1e24; --fg:#e7e9ec; --mute:#9aa3ae; --line:#2b313a; --acc:#6b9bff; --me:#1f2b44; --ok:#3fb950; }
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
body { margin:0; background:var(--bg); color:var(--fg); font:15px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif; }
|
||||
main { max-width:860px; margin:0 auto; padding:16px; display:flex; flex-direction:column; gap:12px; min-height:100vh; }
|
||||
.card { background:var(--card); border:1px solid var(--line); border-radius:12px; padding:14px 16px; }
|
||||
h1 { font-size:20px; margin:0; display:flex; align-items:center; gap:8px; }
|
||||
.dot { width:10px; height:10px; border-radius:50%; background:var(--mute); display:inline-block; }
|
||||
.dot.on { background:var(--ok); }
|
||||
.mute { color:var(--mute); font-size:13px; }
|
||||
code { background:var(--bg); border:1px solid var(--line); border-radius:6px; padding:1px 6px; font-size:13px; }
|
||||
.grid { display:grid; grid-template-columns: max-content 1fr; gap:4px 12px; margin-top:8px; font-size:14px; }
|
||||
#log { flex:1; display:flex; flex-direction:column; gap:10px; overflow-y:auto; min-height:240px; }
|
||||
.msg { padding:10px 12px; border-radius:10px; white-space:pre-wrap; word-wrap:break-word; }
|
||||
.msg.user { background:var(--me); align-self:flex-end; max-width:85%; }
|
||||
.msg.bot { background:var(--card); border:1px solid var(--line); }
|
||||
.msg img { max-width:220px; max-height:160px; display:block; border-radius:6px; margin-bottom:6px; }
|
||||
details { color:var(--mute); font-size:13px; margin-bottom:6px; }
|
||||
form { display:flex; gap:8px; align-items:flex-end; flex-wrap:wrap; }
|
||||
textarea { flex:1; min-width:200px; min-height:52px; max-height:200px; resize:vertical; padding:10px; border-radius:10px;
|
||||
border:1px solid var(--line); background:var(--card); color:var(--fg); font:inherit; }
|
||||
button, label.btn { border:1px solid var(--line); background:var(--card); color:var(--fg); border-radius:10px; padding:10px 14px;
|
||||
font:inherit; cursor:pointer; }
|
||||
button.primary { background:var(--acc); border-color:var(--acc); color:#fff; }
|
||||
button:disabled { opacity:.5; cursor:default; }
|
||||
.row { display:flex; gap:14px; align-items:center; flex-wrap:wrap; font-size:13px; color:var(--mute); }
|
||||
#att { font-size:13px; color:var(--mute); }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<main>
|
||||
<div class="card">
|
||||
<h1><span id="dot" class="dot"></span> Strata <span id="state" class="mute">connecting ...</span></h1>
|
||||
<div class="grid">
|
||||
<span class="mute">Model</span><span id="model">-</span>
|
||||
<span class="mute">Context</span><span id="ctx">-</span>
|
||||
<span class="mute">Images</span><span id="img">-</span>
|
||||
<span class="mute">OpenAI API</span><span><code id="oai"></code> (any API key<span id="keynote"></span>)</span>
|
||||
<span class="mute">Anthropic API</span><span><code id="ant"></code></span>
|
||||
</div>
|
||||
<p class="mute" style="margin:10px 0 0">Point any app with an "OpenAI-compatible" or "Anthropic" provider at these
|
||||
addresses. Close the Strata window to stop the model.</p>
|
||||
</div>
|
||||
|
||||
<div id="log" class="card"></div>
|
||||
|
||||
<div class="card">
|
||||
<form id="f">
|
||||
<textarea id="q" placeholder="Ask something ... (Enter sends, Shift+Enter = new line)"></textarea>
|
||||
<label class="btn" id="attbtn" hidden>Picture<input id="file" type="file" accept="image/png,image/jpeg,image/gif,image/bmp" hidden></label>
|
||||
<button class="primary" id="send">Send</button>
|
||||
<button type="button" id="stop" disabled>Stop</button>
|
||||
</form>
|
||||
<div class="row" style="margin-top:8px">
|
||||
<label>Thinking <select id="think" style="padding:4px;border-radius:8px;border:1px solid var(--line);background:var(--card);color:var(--fg)">
|
||||
<option value="none">off - answer at once</option>
|
||||
<option value="low">low</option>
|
||||
<option value="medium" selected>medium</option>
|
||||
<option value="high">high - best on hard questions, slowest</option>
|
||||
</select></label>
|
||||
<span id="att"></span>
|
||||
<button type="button" id="clear" style="padding:4px 10px">New chat</button>
|
||||
<input id="key" type="password" placeholder="API key" hidden style="padding:6px;border-radius:8px;border:1px solid var(--line)">
|
||||
</div>
|
||||
</div>
|
||||
</main>
|
||||
<script>
|
||||
const $ = id => document.getElementById(id);
|
||||
const base = location.origin;
|
||||
$("oai").textContent = base + "/v1";
|
||||
$("ant").textContent = base + "/v1/messages";
|
||||
let history = [], image = null, ctrl = null;
|
||||
|
||||
async function status() {
|
||||
try {
|
||||
const h = await (await fetch("/health")).json();
|
||||
$("dot").classList.add("on"); $("state").textContent = "running";
|
||||
$("model").textContent = h.model; $("ctx").textContent = h.max_context.toLocaleString() + " tokens";
|
||||
$("img").textContent = h.images ? "on" : "off (run setup again and answer yes to images)";
|
||||
$("attbtn").hidden = !h.images;
|
||||
if (h.api_key) { $("key").hidden = false; $("keynote").textContent = " - this server needs its key"; }
|
||||
} catch (e) { $("state").textContent = "not reachable - is the Strata window still open?"; }
|
||||
}
|
||||
status();
|
||||
|
||||
function bubble(cls, text) {
|
||||
const d = document.createElement("div"); d.className = "msg " + cls; d.textContent = text || "";
|
||||
$("log").appendChild(d); $("log").scrollTop = $("log").scrollHeight; return d;
|
||||
}
|
||||
|
||||
$("file").onchange = () => {
|
||||
const f = $("file").files[0]; if (!f) return;
|
||||
const r = new FileReader();
|
||||
r.onload = () => { image = r.result; $("att").textContent = "picture: " + f.name; };
|
||||
r.readAsDataURL(f);
|
||||
};
|
||||
$("clear").onclick = () => { history = []; $("log").innerHTML = ""; };
|
||||
$("stop").onclick = () => ctrl && ctrl.abort();
|
||||
$("q").addEventListener("keydown", e => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); $("f").requestSubmit(); } });
|
||||
|
||||
$("f").onsubmit = async e => {
|
||||
e.preventDefault();
|
||||
const text = $("q").value.trim(); if (!text) return;
|
||||
$("q").value = "";
|
||||
const content = image ? [{type: "image_url", image_url: {url: image}}, {type: "text", text}] : text;
|
||||
const u = bubble("user", "");
|
||||
if (image) { const im = document.createElement("img"); im.src = image; u.appendChild(im); }
|
||||
u.appendChild(document.createTextNode(text));
|
||||
history.push({role: "user", content});
|
||||
image = null; $("att").textContent = ""; $("file").value = "";
|
||||
const b = bubble("bot", ""); const det = document.createElement("details"); const sum = document.createElement("summary");
|
||||
sum.textContent = "thinking"; det.appendChild(sum); const th = document.createElement("div"); det.appendChild(th);
|
||||
const ans = document.createElement("div"); b.appendChild(ans);
|
||||
$("send").disabled = true; $("stop").disabled = false; ctrl = new AbortController();
|
||||
let answer = "";
|
||||
try {
|
||||
const headers = {"Content-Type": "application/json"};
|
||||
if ($("key").value) headers["Authorization"] = "Bearer " + $("key").value;
|
||||
const body = {model: "strata", messages: history, stream: true, max_tokens: 8192};
|
||||
body.reasoning_effort = $("think").value;
|
||||
const r = await fetch("/v1/chat/completions", {method: "POST", headers, body: JSON.stringify(body), signal: ctrl.signal});
|
||||
if (!r.ok) { ans.textContent = "error: " + ((await r.json()).error || {}).message; throw 0; }
|
||||
const rd = r.body.getReader(), dec = new TextDecoder(); let buf = "";
|
||||
for (;;) {
|
||||
const {value, done} = await rd.read(); if (done) break;
|
||||
buf += dec.decode(value, {stream: true});
|
||||
let i;
|
||||
while ((i = buf.indexOf("\n\n")) >= 0) {
|
||||
const line = buf.slice(0, i).trim(); buf = buf.slice(i + 2);
|
||||
if (!line.startsWith("data: ") || line === "data: [DONE]") continue;
|
||||
const d = JSON.parse(line.slice(6)).choices[0].delta;
|
||||
if (d.reasoning_content) { if (!det.parentNode) b.insertBefore(det, ans); th.textContent += d.reasoning_content; }
|
||||
if (d.content) { answer += d.content; ans.textContent = answer; }
|
||||
$("log").scrollTop = $("log").scrollHeight;
|
||||
}
|
||||
}
|
||||
} catch (err) { if (err && err.name === "AbortError") ans.textContent = answer + " [stopped]"; }
|
||||
history.push({role: "assistant", content: answer});
|
||||
$("send").disabled = false; $("stop").disabled = true; ctrl = null;
|
||||
};
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
+572
-58
@@ -6,9 +6,11 @@
|
||||
Endpoints: POST /v1/chat/completions (OpenAI, stream and non-stream), POST /v1/messages (Anthropic, stream and
|
||||
non-stream), GET /v1/models, GET /health. One sequence at a time behind a FIFO (plan: one resident sequence).
|
||||
Images (optional, when the config has a "vision" entry): OpenAI image_url parts and Anthropic image blocks (base64
|
||||
data, http(s) URLs or local file paths; JPEG/PNG/BMP/GIF) go through `strata-vision` (the model's mmproj file) and
|
||||
reach the engine as embeddings (`GENI`).
|
||||
data, http(s) URLs or local file paths) go through `strata-vision` (the model's mmproj file) and reach the engine as
|
||||
embeddings (`GENI`). JPEG/PNG/BMP/GIF go straight in; WebP, TIFF, AVIF, ... (agents like omp send WebP) are
|
||||
converted to PNG first with Pillow.
|
||||
Requests whose prompt plus max tokens exceed the engine's context are REJECTED with 400, never truncated.
|
||||
An unset (or 0, or -1) max tokens means "unlimited": whatever the prompt leaves of the context.
|
||||
|
||||
The engine boundary is `Engine.generate(prompt_ids, max_new, sampling, cancel) -> iterator of token ids`.
|
||||
`StrataEngine` keeps one `strata --serve` process resident (weights, expert arena and VRAM tier load once) and
|
||||
@@ -17,10 +19,12 @@ talks to it over stdin/stdout; `MockEngine` is a scripted stand-in that makes ev
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import collections
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import queue
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
@@ -40,6 +44,7 @@ from serve.frontend import (ChatTemplate, Event, OutputParser, anthropic_to_mess
|
||||
|
||||
IM_END = "<|im_end|>"
|
||||
IMAGE_PAD = "<|image_pad|>"
|
||||
CTX_SLACK = 8 # `strata --serve` rejects prompt + max_new + 8 > context: keep the same margin here
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------------------------ engines
|
||||
@@ -69,7 +74,12 @@ class MockEngine:
|
||||
|
||||
class StrataEngine:
|
||||
"""The resident engine: `strata --serve` reads `GEN <max_new> <ids>` lines and streams `T <id>` lines, then
|
||||
`DONE ...`. Requests are serialized by the service's FIFO, so one pipe is enough."""
|
||||
`DONE ...`. Requests are serialized by the service's FIFO, so one pipe is enough.
|
||||
|
||||
Per-request sampling rides the same line as engine-side keys between max_new and the ids
|
||||
(`temperature=F top_p=F top_k=N seed=N`, the engine's own spelling). An absent temperature keeps the
|
||||
engine's default, which is greedy; `temperature=0` means the same thing, so it is not forwarded.
|
||||
"""
|
||||
|
||||
def __init__(self, exe: str, args: list[str], cwd: str | None = None, log: str | None = None,
|
||||
env: dict | None = None):
|
||||
@@ -77,38 +87,142 @@ class StrataEngine:
|
||||
self.proc = subprocess.Popen([exe, "--serve", *args], cwd=cwd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
|
||||
stderr=self.log, text=True, encoding="utf-8", bufsize=1, env=env)
|
||||
self.max_context = 0
|
||||
self.can_stop = False # the engine honours a STOP line mid-request (READY <ctx> stop)
|
||||
self.last = {}
|
||||
self.info = {} # INFO key=value facts (engine 0.1.8+): kv, expert slots, ... (Monitor tab)
|
||||
self.progress = None # (read, total) prompt tokens while a prompt is read, from PP lines
|
||||
try: # a ready-made engine's BUILD.json says its version
|
||||
self.info["version"] = json.loads((Path(exe).parent / "BUILD.json").read_text()).get("version")
|
||||
except (OSError, ValueError):
|
||||
self.info["version"] = None
|
||||
for line in self.proc.stdout:
|
||||
if line.startswith("INFO "):
|
||||
for kv in line.split()[1:]:
|
||||
k, _, v = kv.partition("=")
|
||||
self.info[k] = int(v) if v.lstrip("-").isdigit() else v
|
||||
if line.startswith("READY"):
|
||||
self.max_context = int(line.split()[1])
|
||||
f = line.split()
|
||||
self.max_context = int(f[1])
|
||||
self.can_stop = "stop" in f[2:]
|
||||
break
|
||||
if self.max_context <= 0:
|
||||
raise RuntimeError("the engine exited before it was ready" + (f" (see {log})" if log else ""))
|
||||
# the engine's stdout on a thread, so a request can wait with a timeout (heartbeats, cancel checks)
|
||||
self.lines: queue.Queue = queue.Queue()
|
||||
threading.Thread(target=self._pump, daemon=True).start()
|
||||
|
||||
def _pump(self):
|
||||
for line in self.proc.stdout:
|
||||
self.lines.put(line)
|
||||
self.lines.put(None)
|
||||
|
||||
def _parse_done(self, line):
|
||||
f = line.split()
|
||||
self.last = {"generated": int(f[1]), "prompt_tokens": int(f[2]), "prompt_ms": float(f[3]),
|
||||
"decode_ms": float(f[4]), "finish": f[5]}
|
||||
if len(f) >= 9: # the conversation cache's fields (engine 0.1.3+)
|
||||
self.last.update(drafts_accepted=int(f[6]), drafts_offered=int(f[7]), reused=int(f[8]))
|
||||
|
||||
@staticmethod
|
||||
def sampling_keys(sampling: dict) -> str:
|
||||
keys = ""
|
||||
t = sampling.get("temperature")
|
||||
if isinstance(t, (int, float)) and float(t) > 0.0:
|
||||
keys += f" temperature={float(t)!r}"
|
||||
tp = sampling.get("top_p")
|
||||
if isinstance(tp, (int, float)) and float(tp) < 1.0:
|
||||
keys += f" top_p={float(tp)!r}"
|
||||
tk = sampling.get("top_k")
|
||||
if isinstance(tk, int) and 1 <= tk <= 64:
|
||||
keys += f" top_k={tk}" # the engine's sampled path takes 1..64; outside it keeps its 20
|
||||
mp = sampling.get("min_p")
|
||||
if isinstance(mp, (int, float)) and 0.0 < float(mp) <= 1.0:
|
||||
keys += f" min_p={float(mp)!r}"
|
||||
rp = sampling.get("repetition_penalty")
|
||||
rp_on = isinstance(rp, (int, float)) and float(rp) != 1.0
|
||||
pf = sampling.get("frequency_penalty")
|
||||
pf_on = isinstance(pf, (int, float)) and float(pf) != 0.0
|
||||
pp = sampling.get("presence_penalty")
|
||||
pp_on = isinstance(pp, (int, float)) and float(pp) != 0.0
|
||||
if rp_on:
|
||||
keys += f" penalty_repeat={float(rp)!r}"
|
||||
if pf_on:
|
||||
keys += f" penalty_freq={float(pf)!r}"
|
||||
if pp_on:
|
||||
keys += f" penalty_present={float(pp)!r}"
|
||||
if rp_on or pf_on or pp_on:
|
||||
# a penalty without a window counts over nothing: the engine's default is the last 64 tokens
|
||||
pln = sampling.get("penalty_last_n")
|
||||
if isinstance(pln, int) and not isinstance(pln, bool) and pln > 0:
|
||||
keys += f" penalty_last_n={pln}"
|
||||
else:
|
||||
keys += " penalty_last_n=64"
|
||||
seed = sampling.get("seed")
|
||||
if isinstance(seed, int) and seed > 0:
|
||||
keys += f" seed={seed}"
|
||||
return keys + StrataEngine.projection_key(sampling)
|
||||
|
||||
@staticmethod
|
||||
def projection_key(sampling: dict) -> str:
|
||||
"""`cvec=0|1`: the experimental-speed-projection control vector for this request, when the engine was
|
||||
started with one (--control-vector-scaled; an engine without one ignores the key). Absent = on."""
|
||||
on = sampling.get("experimental_speed_projection")
|
||||
return f" cvec={int(on)}" if isinstance(on, bool) else ""
|
||||
|
||||
def generate(self, ids, max_new, sampling, cancel, embeddings=None):
|
||||
head = f"GENI {int(max_new)} {embeddings}" if embeddings else f"GEN {int(max_new)}"
|
||||
"""Yields token ids, and None as a heartbeat every 10 s while the engine is quiet (reading a long prompt):
|
||||
the HTTP layer turns it into an SSE comment, which keeps clients' watchdogs calm and notices a client that
|
||||
has gone. A consumer that stops early (or `cancel`) makes the engine STOP, so it does not run to max_new."""
|
||||
self.progress = None
|
||||
head = f"GENI {int(max_new)}{self.projection_key(sampling or {})} {embeddings}" if embeddings else \
|
||||
f"GEN {int(max_new)}{self.sampling_keys(sampling or {}) if not embeddings else ''}"
|
||||
self.proc.stdin.write(f"{head} {','.join(str(int(t)) for t in ids)}\n")
|
||||
self.proc.stdin.flush()
|
||||
done = False
|
||||
try:
|
||||
for line in self.proc.stdout:
|
||||
while True:
|
||||
try:
|
||||
line = self.lines.get(timeout=10)
|
||||
except queue.Empty:
|
||||
if cancel.is_set():
|
||||
return
|
||||
yield None
|
||||
continue
|
||||
if line is None:
|
||||
done = True
|
||||
raise RuntimeError("the engine process ended")
|
||||
if line.startswith("T "):
|
||||
if not cancel.is_set():
|
||||
yield int(line[2:])
|
||||
elif line.startswith("DONE"):
|
||||
if cancel.is_set():
|
||||
return
|
||||
yield int(line[2:])
|
||||
elif line.startswith("PP "):
|
||||
f = line.split()
|
||||
self.last = {"generated": int(f[1]), "prompt_tokens": int(f[2]), "prompt_ms": float(f[3]),
|
||||
"decode_ms": float(f[4]), "finish": f[5]}
|
||||
if len(f) >= 3 and f[1].isdigit() and f[2].isdigit():
|
||||
self.progress = (int(f[1]), int(f[2])) # prompt progress, one per chunk: also a heartbeat (the
|
||||
if cancel.is_set(): # lines reset the 10 s wait, so without this a long prompt
|
||||
return # would send no keep-alives at all)
|
||||
yield None
|
||||
elif line.startswith("DONE"):
|
||||
self._parse_done(line)
|
||||
done = True
|
||||
return
|
||||
elif line.startswith("ERR"):
|
||||
done = True
|
||||
raise ValueError(line[4:].strip())
|
||||
raise RuntimeError("the engine process ended")
|
||||
finally:
|
||||
if not done: # the consumer stopped early: drain to DONE
|
||||
for line in self.proc.stdout:
|
||||
if line.startswith("DONE") or line.startswith("ERR"):
|
||||
if not done: # the consumer stopped early: stop the engine, drain to DONE
|
||||
if self.can_stop:
|
||||
try:
|
||||
self.proc.stdin.write("STOP\n")
|
||||
self.proc.stdin.flush()
|
||||
except OSError:
|
||||
pass
|
||||
while True:
|
||||
line = self.lines.get()
|
||||
if line is None or line.startswith("ERR"):
|
||||
break
|
||||
if line.startswith("DONE"):
|
||||
self._parse_done(line)
|
||||
break
|
||||
|
||||
def close(self):
|
||||
@@ -155,9 +269,37 @@ class Vision:
|
||||
return Path(path).read_bytes()
|
||||
raise ValueError("an image must be a data: URL, an http(s) URL or a local file path")
|
||||
|
||||
@staticmethod
|
||||
def normalize(data: bytes) -> bytes:
|
||||
"""The formats strata-vision's decoder (stb_image) reads pass through; anything else is converted to PNG."""
|
||||
if data[:3] == b"\xff\xd8\xff" or data[:8] == b"\x89PNG\r\n\x1a\n" or data[:2] == b"BM" or \
|
||||
data[:6] in (b"GIF87a", b"GIF89a"):
|
||||
return data
|
||||
try:
|
||||
import io
|
||||
from PIL import Image
|
||||
except ImportError:
|
||||
raise ValueError("this image format needs Pillow (python -m pip install pillow); JPEG, PNG, BMP and "
|
||||
"GIF work without it") from None
|
||||
try:
|
||||
im = Image.open(io.BytesIO(data))
|
||||
im.load()
|
||||
except Exception as e:
|
||||
raise ValueError(f"the image could not be read ({e})") from None
|
||||
if im.mode in ("RGBA", "LA", "P") and "transparency" in im.info or im.mode in ("RGBA", "LA"):
|
||||
im = im.convert("RGBA")
|
||||
bg = Image.new("RGB", im.size, (255, 255, 255)) # transparent areas become white, not black
|
||||
bg.paste(im, mask=im.split()[-1])
|
||||
im = bg
|
||||
elif im.mode != "RGB":
|
||||
im = im.convert("RGB")
|
||||
out = io.BytesIO()
|
||||
im.save(out, format="PNG")
|
||||
return out.getvalue()
|
||||
|
||||
def encode(self, source: str) -> tuple[Path, int]:
|
||||
"""-> (embeddings file, number of image tokens)."""
|
||||
data = self.load(source)
|
||||
data = self.normalize(self.load(source))
|
||||
key = hashlib.sha256(data).hexdigest()[:32]
|
||||
with self.lock:
|
||||
if key in self.cache:
|
||||
@@ -240,15 +382,64 @@ class Detokenizer:
|
||||
|
||||
class Service:
|
||||
def __init__(self, engine: Engine, tokenizer, template: ChatTemplate, model_name: str = "qwen3.8-flash-next",
|
||||
vision: Vision | None = None):
|
||||
vision: Vision | None = None, sampling_defaults: dict | None = None,
|
||||
fit_max_tokens: bool = False):
|
||||
self.engine, self.tok, self.template, self.model, self.vision = engine, tokenizer, template, model_name, vision
|
||||
self.fit_max_tokens = fit_max_tokens # --fit-max-tokens: clamp the output cap instead of 400
|
||||
self.sampling_defaults = dict(sampling_defaults or {}) # the run config's `sampling` block
|
||||
self.fifo = threading.Lock()
|
||||
self.embeddings = threading.local() # the current request's image embeddings file (GENI)
|
||||
self.api_key = "" # when set, /v1/* needs it (Bearer or x-api-key)
|
||||
self.status = {"busy": False, "queued": 0} # GET /status: what the model is doing right now
|
||||
self.history = collections.deque(maxlen=30) # the last finished requests, newest last (GET /metrics)
|
||||
self.status_lock = threading.Lock()
|
||||
self.stop_ids = set(tokenizer.encode(IM_END, parse_special=True) +
|
||||
tokenizer.encode("<|endoftext|>", parse_special=True))
|
||||
|
||||
def prepare(self, messages, tools, kwargs, max_new):
|
||||
def start_telemetry(self):
|
||||
"""The hardware sampler behind GET /metrics (serve/telemetry.py), recording this server's tok/s too."""
|
||||
if getattr(self, "telemetry", None) is None:
|
||||
from serve.telemetry import Telemetry
|
||||
self.telemetry = Telemetry(extra=lambda: {"tok_s": self._tok_s()})
|
||||
|
||||
def _tok_s(self):
|
||||
with self.status_lock:
|
||||
s = dict(self.status)
|
||||
if not s.get("busy") or not s.get("first_token"):
|
||||
return 0.0
|
||||
return s["generated"] / max(1e-6, time.time() - s["first_token"])
|
||||
|
||||
def metrics(self) -> dict:
|
||||
"""GET /metrics: what the Monitor tab shows - the engine's facts, what it is doing, the last requests, and
|
||||
the hardware (with a minute of history per series)."""
|
||||
with self.status_lock:
|
||||
s = dict(self.status)
|
||||
hist = list(self.history)
|
||||
now = time.time()
|
||||
progress = getattr(self.engine, "progress", None)
|
||||
if s.get("busy") and s.get("first_token") is None:
|
||||
state = "reading"
|
||||
elif s.get("busy"):
|
||||
state = "generating"
|
||||
else:
|
||||
state = "idle"
|
||||
live = {"state": state, "queued": s.get("queued", 0), "phase": s.get("phase") if s.get("busy") else None,
|
||||
"prompt_tokens": s.get("prompt_tokens") if s.get("busy") else None,
|
||||
"prompt_read": None, "prompt_total": None, "generated": s.get("generated") if s.get("busy") else None,
|
||||
"max_tokens": s.get("max_tokens") if s.get("busy") else None,
|
||||
"elapsed_s": round(now - s["started"], 1) if s.get("busy") and s.get("started") else None,
|
||||
"tok_s": round(self._tok_s(), 1) if state == "generating" else None}
|
||||
if state == "reading" and progress:
|
||||
live["prompt_read"], live["prompt_total"] = progress
|
||||
engine = {"model": self.model, "max_context": self.engine.max_context, "images": self.vision is not None,
|
||||
**dict(getattr(self.engine, "info", {}) or {})}
|
||||
tel = self.telemetry.snapshot() if getattr(self, "telemetry", None) else {"now": {}, "history": {}, "static": {}}
|
||||
return {"engine": engine, "live": live, "requests": hist[::-1], "hardware": tel["now"], "hardware_static":
|
||||
tel["static"], "history": tel["history"], "time": now}
|
||||
|
||||
def prepare(self, messages, tools, kwargs, max_new=None):
|
||||
"""-> (ids, thinking, max_new). An unset or non-positive max_new (some clients send -1) means "unlimited":
|
||||
the rest of the context."""
|
||||
prompt = self.template.render(messages, tools=tools, **kwargs)
|
||||
ids = self.tok.encode(prompt, parse_special=True)
|
||||
self.embeddings.path = None
|
||||
@@ -258,7 +449,12 @@ class Service:
|
||||
raise ValueError("this server was started without the vision encoder (run setup again and choose "
|
||||
"'vision'), so it cannot read images")
|
||||
pad = self.tok.encode(IMAGE_PAD, parse_special=True)[0]
|
||||
encoded = [self.vision.encode(src) for src in images]
|
||||
# Encode only while the engine is idle: the engine and the image encoder (a separate process) must not
|
||||
# run on the GPU at the same time - an encode during a running request left that request stuck at
|
||||
# "reading the prompt" with CPU and GPU busy, for good (reproduced). So encoding takes its turn in the
|
||||
# same FIFO as the requests.
|
||||
with self.fifo:
|
||||
encoded = [self.vision.encode(src) for src in images]
|
||||
out, k = [], 0
|
||||
for t in ids: # one <|image_pad|> per image -> one per image token
|
||||
if t == pad and k < len(encoded):
|
||||
@@ -274,34 +470,143 @@ class Service:
|
||||
for path, _ in encoded:
|
||||
f.write(path.read_bytes())
|
||||
self.embeddings.path = combined
|
||||
if len(ids) + max_new > self.engine.max_context:
|
||||
raise ValueError(f"prompt ({len(ids)} tokens) + max tokens ({max_new}) exceeds the context "
|
||||
f"({self.engine.max_context}); requests are never truncated")
|
||||
return ids, kwargs.get("enable_thinking", True) is not False
|
||||
room = self.engine.max_context - CTX_SLACK - len(ids)
|
||||
if max_new is None or max_new <= 0 or (self.fit_max_tokens and room < 1):
|
||||
if room < 1:
|
||||
raise ValueError(f"prompt ({len(ids)} tokens) leaves no room to answer in the context "
|
||||
f"({self.engine.max_context}); requests are never truncated")
|
||||
max_new = room
|
||||
elif max_new > room:
|
||||
if not self.fit_max_tokens:
|
||||
raise ValueError(f"prompt ({len(ids)} tokens) + max tokens ({max_new}) exceeds the context "
|
||||
f"({self.engine.max_context}); requests are never truncated")
|
||||
max_new = max(1, room) # --fit-max-tokens: a shorter completion beats a 400
|
||||
return ids, kwargs.get("enable_thinking", True) is not False, max_new
|
||||
|
||||
def _note(self, n, evs):
|
||||
with self.status_lock:
|
||||
s = self.status
|
||||
s["generated"] = n
|
||||
if s.get("first_token") is None:
|
||||
s["first_token"] = time.time()
|
||||
for ev in evs:
|
||||
if ev.kind == "reasoning":
|
||||
s["phase"] = "thinking"
|
||||
elif ev.kind == "content":
|
||||
s["phase"] = "answering"
|
||||
elif ev.kind == "tool_start":
|
||||
s["phase"], s["tool"] = f"writing a tool call: {ev.call.name}", ev.call.name
|
||||
elif ev.kind == "tool_call":
|
||||
s["phase"] = "tool call complete"
|
||||
s["tail"] = (s["tail"] + (ev.text or ""))[-600:]
|
||||
|
||||
def _progress(self, last_print, every=1.0):
|
||||
"""A progress line in the server window every `every` seconds while a request runs."""
|
||||
now = time.time()
|
||||
if now - last_print < every:
|
||||
return last_print
|
||||
with self.status_lock:
|
||||
s = dict(self.status)
|
||||
el = now - s.get("started", now)
|
||||
if s.get("first_token") is None:
|
||||
print(f"[strata] reading the prompt: {s.get('prompt_tokens', 0)} tokens, {el:.0f} s so far", flush=True)
|
||||
else:
|
||||
rate = s["generated"] / max(1e-6, now - s["first_token"])
|
||||
print(f"[strata] {s['phase']}: {s['generated']} of max {s.get('max_tokens')} tokens, {rate:.1f} tok/s, "
|
||||
f"{el:.0f} s", flush=True)
|
||||
return now
|
||||
|
||||
def run(self, ids, thinking, tools, max_new, sampling, cancel) -> Iterator[tuple[str, object]]:
|
||||
"""Yields ("event", Event) as text arrives, then ("done", {"finish": .., "completion_tokens": ..})."""
|
||||
parser, detok, n, finish = OutputParser(thinking=thinking, tools=tools), Detokenizer(self.tok), 0, "length"
|
||||
if self.sampling_defaults: # config defaults; the request's own fields win (explicit 0 stays greedy)
|
||||
req_values = {k: v for k, v in (sampling or {}).items() if v is not None}
|
||||
sampling = {**self.sampling_defaults, **req_values}
|
||||
parser = OutputParser(thinking=thinking, tools=tools, stream_tools=True)
|
||||
detok, n, finish = Detokenizer(self.tok), 0, "length"
|
||||
raw_ids = [] # every generated id (STRATA_DEBUG: dump raw model text)
|
||||
emb = getattr(self.embeddings, "path", None)
|
||||
with self.status_lock:
|
||||
self.status["queued"] += 1
|
||||
try:
|
||||
with self.fifo:
|
||||
with self.status_lock:
|
||||
self.status["queued"] -= 1
|
||||
self.status.update(busy=True, phase="reading the prompt", prompt_tokens=len(ids), generated=0,
|
||||
started=time.time(), first_token=None, tool=None, tail="", max_tokens=max_new)
|
||||
last_print = time.time()
|
||||
gen = self.engine.generate(ids, max_new, sampling, cancel, embeddings=emb) if emb else \
|
||||
self.engine.generate(ids, max_new, sampling, cancel)
|
||||
for t in gen:
|
||||
n += 1
|
||||
if t in self.stop_ids:
|
||||
finish = "stop"
|
||||
break
|
||||
for ev in parser.feed(detok.push(t)):
|
||||
yield "event", ev
|
||||
try:
|
||||
for t in gen:
|
||||
if t is None: # heartbeat while the engine is quiet
|
||||
last_print = self._progress(last_print)
|
||||
yield "ping", None
|
||||
continue
|
||||
n += 1
|
||||
if t in self.stop_ids:
|
||||
finish = "stop"
|
||||
raw_ids.append(t)
|
||||
break
|
||||
raw_ids.append(t)
|
||||
evs = parser.feed(detok.push(t))
|
||||
self._note(n, evs)
|
||||
last_print = self._progress(last_print)
|
||||
for ev in evs:
|
||||
yield "event", ev
|
||||
if cancel.is_set():
|
||||
finish = "cancel"
|
||||
finally:
|
||||
gen.close() # STOP+drain to THIS request's DONE while still holding the
|
||||
# fifo, so a stop-token break can't leave the shared engine
|
||||
# queue mid-drain for the next request to read as its own DONE
|
||||
except GeneratorExit: # the client disconnected mid-stream
|
||||
finish = "disconnect"
|
||||
raise
|
||||
finally:
|
||||
if emb:
|
||||
Path(emb).unlink(missing_ok=True)
|
||||
with self.status_lock:
|
||||
if self.status.get("busy"):
|
||||
last = dict(getattr(self.engine, "last", {}) or {})
|
||||
started = self.status.get("started", time.time())
|
||||
loaded = str((getattr(self.engine, "info", {}) or {}).get("cvec", 0)) not in ("0", "", "None")
|
||||
self.history.append({
|
||||
"projection": (sampling or {}).get("experimental_speed_projection") is not False
|
||||
if loaded else None,
|
||||
"time": started, "duration_s": round(time.time() - started, 1), "finish": finish,
|
||||
"prompt_tokens": len(ids), "reused": last.get("reused"), "output_tokens": n,
|
||||
"prompt_ms": last.get("prompt_ms"), "decode_ms": last.get("decode_ms"),
|
||||
"decode_tok_s": round(last["generated"] / (last["decode_ms"] / 1000), 1)
|
||||
if n and last.get("generated") and last.get("decode_ms") else None})
|
||||
now = time.time()
|
||||
el = now - self.status.get("started", now)
|
||||
ft = self.status.get("first_token")
|
||||
rate = n / max(1e-6, now - ft) if ft else 0.0
|
||||
print(f"[strata] done: {n} tokens in {el:.0f} s ({rate:.1f} tok/s) "
|
||||
f"({finish}, cancel={cancel.is_set()})", flush=True)
|
||||
if os.environ.get("STRATA_DEBUG") and raw_ids:
|
||||
print(f"[strata] raw: {self.tok.decode(raw_ids)!r}", flush=True)
|
||||
self.status["busy"] = False
|
||||
for ev in parser.finish():
|
||||
yield "event", ev
|
||||
yield "done", {"finish": finish, "completion_tokens": n}
|
||||
|
||||
|
||||
def _debug_req(api, req, messages, tools, max_new, thinking, prompt_tokens):
|
||||
"""One compact line per request while diagnosing blank/empty turns. Set STRATA_DEBUG=1 to enable."""
|
||||
if not os.environ.get("STRATA_DEBUG"):
|
||||
return
|
||||
last = messages[-1] if messages else {}
|
||||
body = last.get("content")
|
||||
if isinstance(body, list):
|
||||
body = " ".join(p.get("text", "") for p in body if isinstance(p, dict))
|
||||
preview = (str(body or "")[:80]).replace("\n", " ")
|
||||
print(f"[strata] req {api}: msgs={len(messages)} tools={len(tools or [])} "
|
||||
f"max_tokens_raw={req.get('max_tokens')!r}/{req.get('max_completion_tokens')!r} "
|
||||
f"max_new={max_new} thinking={thinking} stream={bool(req.get('stream'))} "
|
||||
f"prompt_tokens={prompt_tokens} last={last.get('role')!r}:{preview!r}", flush=True)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------------------------ OpenAI
|
||||
def openai_chunks(svc: Service, req: dict, ids, thinking, tools, max_new, cancel):
|
||||
cid, created = "chatcmpl-" + uuid.uuid4().hex[:24], int(time.time())
|
||||
@@ -312,20 +617,32 @@ def openai_chunks(svc: Service, req: dict, ids, thinking, tools, max_new, cancel
|
||||
|
||||
yield chunk({"role": "assistant", "content": ""})
|
||||
calls = 0
|
||||
streamed = {} # tool call id -> index, for calls sent piece by piece
|
||||
for kind, x in svc.run(ids, thinking, tools, max_new, req, cancel):
|
||||
if kind == "event":
|
||||
if kind == "ping":
|
||||
yield None
|
||||
elif kind == "event":
|
||||
ev: Event = x
|
||||
if ev.kind == "reasoning" and ev.text:
|
||||
yield chunk({"reasoning_content": ev.text})
|
||||
elif ev.kind == "content" and ev.text:
|
||||
yield chunk({"content": ev.text})
|
||||
elif ev.kind == "tool_start":
|
||||
streamed[ev.call.id] = calls
|
||||
calls += 1
|
||||
yield chunk({"tool_calls": [{"index": streamed[ev.call.id], "id": ev.call.id, "type": "function",
|
||||
"function": {"name": ev.call.name, "arguments": ""}}]})
|
||||
elif ev.kind == "tool_args":
|
||||
yield chunk({"tool_calls": [{"index": streamed[ev.call.id], "function": {"arguments": ev.text}}]})
|
||||
elif ev.kind == "tool_call" and ev.call.id in streamed:
|
||||
continue
|
||||
elif ev.kind == "tool_call":
|
||||
yield chunk({"tool_calls": [{"index": calls, "id": ev.call.id, "type": "function",
|
||||
"function": {"name": ev.call.name,
|
||||
"arguments": json.dumps(ev.call.arguments, ensure_ascii=False)}}]})
|
||||
calls += 1
|
||||
else:
|
||||
finish = "tool_calls" if calls and x["finish"] == "stop" else x["finish"]
|
||||
finish = "tool_calls" if calls and x["finish"] == "stop" else {"cancel": "stop"}.get(x["finish"], x["finish"])
|
||||
last = chunk({}, finish)
|
||||
last["usage"] = {"prompt_tokens": len(ids), "completion_tokens": x["completion_tokens"],
|
||||
"total_tokens": len(ids) + x["completion_tokens"]}
|
||||
@@ -333,13 +650,22 @@ def openai_chunks(svc: Service, req: dict, ids, thinking, tools, max_new, cancel
|
||||
|
||||
|
||||
def openai_collect(chunks) -> dict:
|
||||
content, reasoning, calls, last = [], [], [], None
|
||||
content, reasoning, by_index, last = [], [], {}, None
|
||||
for c in chunks:
|
||||
if c is None: # a heartbeat
|
||||
continue
|
||||
d = c["choices"][0]["delta"]
|
||||
content.append(d.get("content") or "")
|
||||
reasoning.append(d.get("reasoning_content") or "")
|
||||
calls += [{k: v for k, v in tc.items() if k != "index"} for tc in d.get("tool_calls") or []]
|
||||
for tc in d.get("tool_calls") or []: # streamed calls arrive in pieces: merge them by index
|
||||
cur = by_index.setdefault(tc.get("index", len(by_index)), {"id": None, "type": "function",
|
||||
"function": {"name": "", "arguments": ""}})
|
||||
cur["id"] = tc.get("id") or cur["id"]
|
||||
fn = tc.get("function") or {}
|
||||
cur["function"]["name"] += fn.get("name") or ""
|
||||
cur["function"]["arguments"] += fn.get("arguments") or ""
|
||||
last = c
|
||||
calls = [by_index[i] for i in sorted(by_index)]
|
||||
msg = {"role": "assistant", "content": "".join(content) or None}
|
||||
if "".join(reasoning):
|
||||
msg["reasoning_content"] = "".join(reasoning)
|
||||
@@ -361,12 +687,25 @@ def anthropic_events(svc: Service, req: dict, ids, thinking, tools, max_new, can
|
||||
def close():
|
||||
return ("content_block_stop", {"type": "content_block_stop", "index": index})
|
||||
|
||||
streamed = set()
|
||||
for kind, x in svc.run(ids, thinking, tools, max_new, req, cancel):
|
||||
if kind == "ping":
|
||||
yield None
|
||||
continue
|
||||
if kind == "event":
|
||||
ev: Event = x
|
||||
want = {"reasoning": "thinking", "content": "text", "tool_call": "tool_use"}[ev.kind]
|
||||
if ev.kind != "tool_call" and not ev.text:
|
||||
if ev.kind == "tool_args":
|
||||
yield "content_block_delta", {"type": "content_block_delta", "index": index,
|
||||
"delta": {"type": "input_json_delta", "partial_json": ev.text}}
|
||||
continue
|
||||
if ev.kind == "tool_call" and ev.call.id in streamed:
|
||||
continue
|
||||
want = {"reasoning": "thinking", "content": "text", "tool_call": "tool_use", "tool_start": "tool_use"}[ev.kind]
|
||||
if ev.kind not in ("tool_call", "tool_start") and not ev.text:
|
||||
continue
|
||||
if ev.kind == "tool_start":
|
||||
streamed.add(ev.call.id)
|
||||
used_tool = True
|
||||
if open_kind != want or want == "tool_use":
|
||||
if open_kind is not None:
|
||||
yield close()
|
||||
@@ -383,6 +722,8 @@ def anthropic_events(svc: Service, req: dict, ids, thinking, tools, max_new, can
|
||||
elif want == "text":
|
||||
yield "content_block_delta", {"type": "content_block_delta", "index": index,
|
||||
"delta": {"type": "text_delta", "text": ev.text}}
|
||||
elif ev.kind == "tool_start":
|
||||
pass # its input follows as tool_args pieces
|
||||
else:
|
||||
used_tool = True
|
||||
yield "content_block_delta", {"type": "content_block_delta", "index": index, "delta": {
|
||||
@@ -391,7 +732,7 @@ def anthropic_events(svc: Service, req: dict, ids, thinking, tools, max_new, can
|
||||
if open_kind is not None:
|
||||
yield close()
|
||||
stop = "tool_use" if used_tool and x["finish"] == "stop" else \
|
||||
{"stop": "end_turn", "length": "max_tokens"}[x["finish"]]
|
||||
{"stop": "end_turn", "length": "max_tokens", "cancel": "end_turn"}[x["finish"]]
|
||||
yield "message_delta", {"type": "message_delta", "delta": {"stop_reason": stop, "stop_sequence": None},
|
||||
"usage": {"output_tokens": x["completion_tokens"]}}
|
||||
yield "message_stop", {"type": "message_stop"}
|
||||
@@ -399,7 +740,10 @@ def anthropic_events(svc: Service, req: dict, ids, thinking, tools, max_new, can
|
||||
|
||||
def anthropic_collect(events) -> dict:
|
||||
msg, blocks = None, []
|
||||
for name, e in events:
|
||||
for item in events:
|
||||
if item is None: # a heartbeat
|
||||
continue
|
||||
name, e = item
|
||||
if name == "message_start":
|
||||
msg = e["message"]
|
||||
elif name == "content_block_start":
|
||||
@@ -410,8 +754,11 @@ def anthropic_collect(events) -> dict:
|
||||
b["text"] += d["text"]
|
||||
elif d["type"] == "thinking_delta":
|
||||
b["thinking"] += d["thinking"]
|
||||
else:
|
||||
b["input"] = json.loads(d["partial_json"])
|
||||
else: # input_json_delta pieces: parsed when complete
|
||||
b["_json"] = b.get("_json", "") + d["partial_json"]
|
||||
elif name == "content_block_stop" and blocks and "_json" in blocks[-1]:
|
||||
b = blocks[-1]
|
||||
b["input"] = json.loads(b.pop("_json") or "{}")
|
||||
elif name == "message_delta":
|
||||
msg["stop_reason"] = e["delta"]["stop_reason"]
|
||||
msg["usage"]["output_tokens"] = e["usage"]["output_tokens"]
|
||||
@@ -447,8 +794,45 @@ def make_handler(svc: Service):
|
||||
|
||||
def do_GET(self):
|
||||
path = self.path.split("?")[0].rstrip("/")
|
||||
if path.startswith("/fonts/"):
|
||||
# the web app's font (Outfit, OFL: serve/web/fonts); the page falls back to the system font
|
||||
name = path[len("/fonts/"):]
|
||||
f = ROOT / "serve" / "web" / "fonts" / name
|
||||
if "/" in name or "\\" in name or not name.endswith(".woff2") or not f.is_file():
|
||||
self._json(404, {"error": {"message": "not found"}})
|
||||
return
|
||||
body = f.read_bytes()
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", "font/woff2")
|
||||
self.send_header("Cache-Control", "max-age=86400")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
return
|
||||
if path.startswith("/web/"):
|
||||
# the web app's own files (serve/web): styles, script, icon sprite - same origin, no CDN
|
||||
name = path[len("/web/"):]
|
||||
types = {".css": "text/css; charset=utf-8", ".js": "text/javascript; charset=utf-8",
|
||||
".svg": "image/svg+xml"}
|
||||
f = ROOT / "serve" / "web" / name
|
||||
ext = os.path.splitext(name)[1]
|
||||
if "/" in name or "\\" in name or ext not in types or not f.is_file():
|
||||
self._json(404, {"error": {"message": "not found"}})
|
||||
return
|
||||
body = f.read_bytes()
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", types[ext])
|
||||
self.send_header("Cache-Control", "no-cache")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
return
|
||||
if path == "/metrics":
|
||||
if self._authorized():
|
||||
self._json(200, svc.metrics())
|
||||
return
|
||||
if path == "":
|
||||
body = (ROOT / "serve" / "index.html").read_bytes()
|
||||
body = (ROOT / "serve" / "web" / "index.html").read_bytes()
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", "text/html; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
@@ -457,6 +841,17 @@ def make_handler(svc: Service):
|
||||
elif path == "/health":
|
||||
self._json(200, {"status": "ok", "max_context": svc.engine.max_context, "model": svc.model,
|
||||
"images": svc.vision is not None, "api_key": bool(svc.api_key)})
|
||||
elif path == "/status":
|
||||
with svc.status_lock:
|
||||
s = dict(svc.status)
|
||||
now = time.time()
|
||||
if s.get("busy"):
|
||||
s["elapsed_s"] = round(now - s["started"], 1)
|
||||
if s.get("first_token"):
|
||||
s["tokens_per_s"] = round(s["generated"] / max(1e-6, now - s["first_token"]), 1)
|
||||
for k in ("started", "first_token"):
|
||||
s.pop(k, None)
|
||||
self._json(200, s)
|
||||
elif path == "/v1/models":
|
||||
if self._authorized():
|
||||
self._json(200, {"object": "list", "data": [{"id": svc.model, "object": "model"}]})
|
||||
@@ -485,8 +880,9 @@ def make_handler(svc: Service):
|
||||
|
||||
def _openai(self, req):
|
||||
messages, tools, kw = openai_to_messages(req)
|
||||
max_new = int(req.get("max_completion_tokens") or req.get("max_tokens") or 1024)
|
||||
ids, thinking = svc.prepare(messages, tools, kw, max_new)
|
||||
max_new = int(req.get("max_completion_tokens") or req.get("max_tokens") or 0) # 0/-1: the rest of the context
|
||||
ids, thinking, max_new = svc.prepare(messages, tools, kw, max_new)
|
||||
_debug_req("openai", req, messages, tools, max_new, thinking, len(ids))
|
||||
cancel = threading.Event()
|
||||
chunks = openai_chunks(svc, req, ids, thinking, tools, max_new, cancel)
|
||||
if not req.get("stream"):
|
||||
@@ -494,28 +890,38 @@ def make_handler(svc: Service):
|
||||
self._sse()
|
||||
try:
|
||||
for c in chunks:
|
||||
self.wfile.write(b"data: " + json.dumps(c, ensure_ascii=False).encode() + b"\n\n")
|
||||
if c is None:
|
||||
self.wfile.write(b": keep-alive\n\n") # an SSE comment: clients ignore it
|
||||
else:
|
||||
self.wfile.write(b"data: " + json.dumps(c, ensure_ascii=False).encode() + b"\n\n")
|
||||
self.wfile.flush()
|
||||
self.wfile.write(b"data: [DONE]\n\n")
|
||||
except OSError:
|
||||
cancel.set() # client went away: stop at the next step
|
||||
cancel.set() # client went away: stop the engine
|
||||
chunks.close()
|
||||
|
||||
def _anthropic(self, req):
|
||||
messages, tools, kw = anthropic_to_messages(req)
|
||||
max_new = int(req.get("max_tokens") or 1024)
|
||||
ids, thinking = svc.prepare(messages, tools, kw, max_new)
|
||||
max_new = int(req.get("max_tokens") or 0) # 0/-1: the rest of the context
|
||||
ids, thinking, max_new = svc.prepare(messages, tools, kw, max_new)
|
||||
_debug_req("anthropic", req, messages, tools, max_new, thinking, len(ids))
|
||||
cancel = threading.Event()
|
||||
events = anthropic_events(svc, req, ids, thinking, tools, max_new, cancel)
|
||||
if not req.get("stream"):
|
||||
return self._json(200, anthropic_collect(events))
|
||||
self._sse()
|
||||
try:
|
||||
for name, e in events:
|
||||
self.wfile.write(f"event: {name}\n".encode() + b"data: " +
|
||||
json.dumps(e, ensure_ascii=False).encode() + b"\n\n")
|
||||
for item in events:
|
||||
if item is None:
|
||||
self.wfile.write(b": keep-alive\n\n")
|
||||
else:
|
||||
name, e = item
|
||||
self.wfile.write(f"event: {name}\n".encode() + b"data: " +
|
||||
json.dumps(e, ensure_ascii=False).encode() + b"\n\n")
|
||||
self.wfile.flush()
|
||||
except OSError:
|
||||
cancel.set()
|
||||
events.close()
|
||||
|
||||
return Handler
|
||||
|
||||
@@ -526,27 +932,111 @@ class Server(ThreadingHTTPServer):
|
||||
allow_reuse_address = os.name != "nt"
|
||||
|
||||
|
||||
def lan_addresses() -> list[str]:
|
||||
"""This PC's IPv4 addresses on its networks (what another device types in), without loopback/link-local."""
|
||||
import socket
|
||||
first, ips = None, set()
|
||||
try: # the address of the default route; sends nothing (UDP)
|
||||
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
|
||||
s.connect(("10.255.255.255", 1))
|
||||
first = s.getsockname()[0]
|
||||
except OSError:
|
||||
pass
|
||||
try:
|
||||
for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET):
|
||||
ips.add(info[4][0])
|
||||
except OSError:
|
||||
pass
|
||||
ok = lambda ip: ip and not ip.startswith(("127.", "169.254.", "0."))
|
||||
return ([first] if ok(first) else []) + sorted(ip for ip in ips if ok(ip) and ip != first)
|
||||
|
||||
|
||||
def serve(svc: Service, host="127.0.0.1", port=8095) -> ThreadingHTTPServer:
|
||||
svc.start_telemetry()
|
||||
httpd = Server((host, port), make_handler(svc))
|
||||
threading.Thread(target=httpd.serve_forever, daemon=True).start()
|
||||
return httpd
|
||||
|
||||
|
||||
def sampling_defaults_from_config(cfg: dict) -> dict:
|
||||
"""The run config's optional `sampling` block: defaults for the sampling fields a request leaves out, so
|
||||
a plain client gets configured sampling instead of greedy. Supported: temperature, top_p, top_k, min_p,
|
||||
presence_penalty, repetition_penalty, frequency_penalty, penalty_last_n, seed. The request's own fields
|
||||
always win - an explicit temperature=0 still means greedy, a field set to null falls back to the default.
|
||||
A bad value refuses to start the server (a typo'd config should not quietly change sampling); unknown keys
|
||||
are named at startup and ignored."""
|
||||
out = {}
|
||||
for key, value in (cfg.get("sampling") or {}).items():
|
||||
if value is None:
|
||||
continue
|
||||
number = isinstance(value, (int, float)) and not isinstance(value, bool)
|
||||
if key == "temperature":
|
||||
if not number or value < 0:
|
||||
raise SystemExit(f"[strata] config sampling.temperature={value!r}: expected a number >= 0 (0 = greedy)")
|
||||
out[key] = float(value)
|
||||
elif key == "top_p":
|
||||
if not number or not 0 < value <= 1:
|
||||
raise SystemExit(f"[strata] config sampling.top_p={value!r}: expected 0 < top_p <= 1")
|
||||
out[key] = float(value)
|
||||
elif key == "min_p":
|
||||
if not number or not 0 <= value <= 1:
|
||||
raise SystemExit(f"[strata] config sampling.min_p={value!r}: expected 0 <= min_p <= 1")
|
||||
out[key] = float(value)
|
||||
elif key == "top_k":
|
||||
if not number or value != int(value) or not 1 <= value <= 64:
|
||||
raise SystemExit(f"[strata] config sampling.top_k={value!r}: the sampled path takes an integer 1..64")
|
||||
out[key] = int(value)
|
||||
elif key == "presence_penalty":
|
||||
if not number or value < 0:
|
||||
raise SystemExit(f"[strata] config sampling.presence_penalty={value!r}: expected a number >= 0")
|
||||
out[key] = float(value)
|
||||
elif key == "frequency_penalty":
|
||||
if not number or value < 0:
|
||||
raise SystemExit(f"[strata] config sampling.frequency_penalty={value!r}: expected a number >= 0")
|
||||
out[key] = float(value)
|
||||
elif key == "repetition_penalty":
|
||||
if not number or value <= 0:
|
||||
raise SystemExit(f"[strata] config sampling.repetition_penalty={value!r}: expected a number > 0 (1 = off)")
|
||||
out[key] = float(value)
|
||||
elif key == "penalty_last_n":
|
||||
if not number or value != int(value) or value < 0:
|
||||
raise SystemExit(f"[strata] config sampling.penalty_last_n={value!r}: expected a non-negative integer")
|
||||
out[key] = int(value)
|
||||
elif key == "seed":
|
||||
if not number or value != int(value) or value <= 0:
|
||||
raise SystemExit(f"[strata] config sampling.seed={value!r}: expected a positive integer")
|
||||
out[key] = int(value)
|
||||
elif key == "experimental_speed_projection":
|
||||
if not isinstance(value, bool):
|
||||
raise SystemExit(f"[strata] config sampling.experimental_speed_projection={value!r}: expected true or "
|
||||
"false (the default for requests that leave it out, when the engine has the vector)")
|
||||
out[key] = value
|
||||
else:
|
||||
print(f"[strata] config sampling.{key}={value!r}: unknown key, ignored", flush=True)
|
||||
return out
|
||||
|
||||
|
||||
def main() -> int:
|
||||
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
ap.add_argument("--engine", choices=["mock", "strata"], default="mock")
|
||||
ap.add_argument("--config", help="strata engine config (JSON: exe, args, cwd, tokenizer, model_name), "
|
||||
"written by setup.py")
|
||||
ap.add_argument("--host", default="127.0.0.1")
|
||||
ap.add_argument("--host", default=None,
|
||||
help="the address to listen on: 127.0.0.1 = this PC only (the default), 0.0.0.0 = also other devices "
|
||||
"on your network (set an API key); also \"host\" in the config")
|
||||
ap.add_argument("--script", default="Thinking about it.</think>\n\nHello from the mock engine.")
|
||||
ap.add_argument("--port", type=int, default=8095)
|
||||
ap.add_argument("--tokenizer", default=str(ROOT / "pack/full/tokenizer"),
|
||||
help="pack tokenizer directory (falls back to a byte tokenizer if absent)")
|
||||
ap.add_argument("--open", action="store_true", help="open the local page in the browser once the model is ready")
|
||||
ap.add_argument("--fit-max-tokens", action="store_true",
|
||||
help="clamp max_tokens to the remaining context instead of rejecting the request "
|
||||
"(default: reject with 400, like llama.cpp; also \"fit_max_tokens\": true in the config)")
|
||||
ap.add_argument("--api-key", default=os.environ.get("STRATA_API_KEY", ""),
|
||||
help="require this key on /v1/* (Authorization: Bearer ... or x-api-key); also $STRATA_API_KEY")
|
||||
a = ap.parse_args()
|
||||
cfg = json.loads(Path(a.config).read_text(encoding="utf-8")) if a.config else {}
|
||||
cfg = json.loads(Path(a.config).read_text(encoding="utf-8-sig")) if a.config else {} # Notepad adds a BOM
|
||||
a.host = a.host or cfg.get("host") or "127.0.0.1" # issue #26: the run scripts pass no --host, the config can
|
||||
try: # before the minutes of loading: is the port free?
|
||||
Server((a.host, a.port), BaseHTTPRequestHandler).server_close()
|
||||
except OSError:
|
||||
@@ -572,6 +1062,10 @@ def main() -> int:
|
||||
ap.error("--engine strata needs --config")
|
||||
vision = None
|
||||
env = child_env(cfg)
|
||||
sampling_defaults = sampling_defaults_from_config(cfg)
|
||||
if sampling_defaults:
|
||||
pretty = ", ".join(f"{k}={v}" for k, v in sampling_defaults.items())
|
||||
print(f"[strata] sampling defaults from the config: {pretty}", flush=True)
|
||||
if cfg.get("vision"):
|
||||
print("loading the vision encoder ...", flush=True)
|
||||
vision = Vision(cfg["vision"], log=open(cfg["log"], "a", encoding="utf-8") if cfg.get("log") else None,
|
||||
@@ -579,15 +1073,35 @@ def main() -> int:
|
||||
print("loading the model (the first start takes a minute or two) ...", flush=True)
|
||||
engine = StrataEngine(cfg["exe"], cfg["args"], cwd=cfg.get("cwd"), log=cfg.get("log"), env=env)
|
||||
else:
|
||||
engine, vision = MockEngine(tok, a.script), None
|
||||
svc = Service(engine, tok, ChatTemplate(ROOT / "serve/chat_template.jinja"),
|
||||
model_name=cfg.get("model_name", "qwen3.8-flash-next"), vision=vision)
|
||||
engine, vision, sampling_defaults = MockEngine(tok, a.script), None, {}
|
||||
# the model's own chat template (exported with its tokenizer), else the original model's
|
||||
tpl = tpath / "chat_template.jinja"
|
||||
svc = Service(engine, tok, ChatTemplate(tpl if tpl.exists() else ROOT / "serve/chat_template.jinja"),
|
||||
model_name=cfg.get("model_name", "qwen3.8-flash-next"), vision=vision,
|
||||
sampling_defaults=sampling_defaults,
|
||||
fit_max_tokens=a.fit_max_tokens or cfg.get("fit_max_tokens") is True)
|
||||
svc.api_key = a.api_key or cfg.get("api_key", "")
|
||||
httpd = serve(svc, host=a.host, port=a.port)
|
||||
print(f"ready: http://{a.host}:{a.port}/v1 (OpenAI: /v1/chat/completions, Anthropic: /v1/messages, "
|
||||
here = "127.0.0.1" if a.host in ("0.0.0.0", "", "::") else a.host
|
||||
print(f"ready: http://{here}:{a.port}/v1 (OpenAI: /v1/chat/completions, Anthropic: /v1/messages, "
|
||||
f"context {engine.max_context} tokens{', images on' if vision else ''}"
|
||||
f"{', API key required' if svc.api_key else ''})", flush=True)
|
||||
print(f" open http://{a.host}:{a.port}/ in a browser to chat; close this window to stop the model", flush=True)
|
||||
print(f" open http://{here}:{a.port}/ in a browser to chat; close this window to stop the model", flush=True)
|
||||
if a.host not in ("127.0.0.1", "localhost", "::1"):
|
||||
# issue #26: reachable from other devices - say at which address, and what can still block it
|
||||
ips = lan_addresses()
|
||||
for ip in ips:
|
||||
print(f" from other devices: http://{ip}:{a.port}/ (API: http://{ip}:{a.port}/v1)", flush=True)
|
||||
if not ips:
|
||||
print(" from other devices: http://<this PC's IP address>:" + str(a.port) + "/", flush=True)
|
||||
if not svc.api_key:
|
||||
print(" WARNING: no API key - anyone on your network can use this model. Add \"api_key\": \"...\" "
|
||||
"to the config (clients send it as their API key; the web page asks for it)", flush=True)
|
||||
if os.name == "nt":
|
||||
print(" nothing arrives? Windows Firewall blocks it until allowed: accept its prompt for Python, or run "
|
||||
"in an admin PowerShell:\n New-NetFirewallRule -DisplayName \"Strata " + str(a.port) + "\" "
|
||||
"-Direction Inbound -Protocol TCP -LocalPort " + str(a.port) + " -Action Allow -Profile Private\n"
|
||||
" (and set this network to Private in Windows' network settings)", flush=True)
|
||||
if a.open:
|
||||
import webbrowser
|
||||
webbrowser.open(f"http://{'127.0.0.1' if a.host in ('0.0.0.0', '') else a.host}:{a.port}/")
|
||||
|
||||
@@ -0,0 +1,246 @@
|
||||
"""serve/telemetry.py - hardware readings for the web app's Monitor tab (idea from PR #22 by code-martin).
|
||||
|
||||
A background thread samples once a second and keeps the last 60 readings of each series for the sparklines:
|
||||
- GPU: NVIDIA's own NVML library (nvml.dll / libnvidia-ml.so.1, installed with every driver) through ctypes, so no
|
||||
pip package is needed: load, VRAM, temperature, power, PCIe link and throughput.
|
||||
- CPU, RAM, disk: `psutil` when it is installed (setup installs it); without it the CPU and RAM readings fall back to
|
||||
the OS (Windows GlobalMemoryStatusEx / GetSystemTimes, Linux /proc) and the disk rate is absent.
|
||||
Anything that cannot be read is None; nothing here can stop the server.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import collections
|
||||
import ctypes
|
||||
import os
|
||||
import platform
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
|
||||
HISTORY = 60
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------------------------ NVML
|
||||
class _Nvml:
|
||||
class Util(ctypes.Structure):
|
||||
_fields_ = [("gpu", ctypes.c_uint), ("memory", ctypes.c_uint)]
|
||||
|
||||
class Mem(ctypes.Structure):
|
||||
_fields_ = [("total", ctypes.c_ulonglong), ("free", ctypes.c_ulonglong), ("used", ctypes.c_ulonglong)]
|
||||
|
||||
def __init__(self, index=0):
|
||||
self.lib = self.dev = None
|
||||
names = ["nvml.dll", os.path.join(os.environ.get("ProgramFiles", r"C:\Program Files"),
|
||||
"NVIDIA Corporation", "NVSMI", "nvml.dll")] if os.name == "nt" \
|
||||
else ["libnvidia-ml.so.1", "libnvidia-ml.so"]
|
||||
for n in names:
|
||||
try:
|
||||
self.lib = ctypes.CDLL(n)
|
||||
break
|
||||
except OSError:
|
||||
continue
|
||||
if self.lib is None:
|
||||
return
|
||||
try:
|
||||
init = getattr(self.lib, "nvmlInit_v2", None) or self.lib.nvmlInit
|
||||
if init() != 0:
|
||||
self.lib = None
|
||||
return
|
||||
h = ctypes.c_void_p()
|
||||
get = getattr(self.lib, "nvmlDeviceGetHandleByIndex_v2", None) or self.lib.nvmlDeviceGetHandleByIndex
|
||||
if get(ctypes.c_uint(index), ctypes.byref(h)) != 0:
|
||||
self.lib = None
|
||||
return
|
||||
self.dev = h
|
||||
except (AttributeError, OSError):
|
||||
self.lib = None
|
||||
|
||||
def ok(self):
|
||||
return self.lib is not None and self.dev is not None
|
||||
|
||||
def _uint(self, fn, *args):
|
||||
v = ctypes.c_uint()
|
||||
try:
|
||||
return v.value if getattr(self.lib, fn)(self.dev, *args, ctypes.byref(v)) == 0 else None
|
||||
except (AttributeError, OSError):
|
||||
return None
|
||||
|
||||
def name(self):
|
||||
buf = ctypes.create_string_buffer(96)
|
||||
try:
|
||||
if self.lib.nvmlDeviceGetName(self.dev, buf, ctypes.c_uint(96)) == 0:
|
||||
return buf.value.decode(errors="replace")
|
||||
except (AttributeError, OSError):
|
||||
pass
|
||||
return None
|
||||
|
||||
def read(self):
|
||||
out = {}
|
||||
u = self.Util()
|
||||
try:
|
||||
if self.lib.nvmlDeviceGetUtilizationRates(self.dev, ctypes.byref(u)) == 0:
|
||||
out["util"] = u.gpu
|
||||
except (AttributeError, OSError):
|
||||
pass
|
||||
m = self.Mem()
|
||||
try:
|
||||
if self.lib.nvmlDeviceGetMemoryInfo(self.dev, ctypes.byref(m)) == 0:
|
||||
out["mem_used"], out["mem_total"] = m.used, m.total
|
||||
except (AttributeError, OSError):
|
||||
pass
|
||||
out["temp"] = self._uint("nvmlDeviceGetTemperature", ctypes.c_uint(0)) # NVML_TEMPERATURE_GPU
|
||||
mw = self._uint("nvmlDeviceGetPowerUsage")
|
||||
out["power"] = mw / 1000.0 if mw is not None else None
|
||||
lim = self._uint("nvmlDeviceGetEnforcedPowerLimit")
|
||||
out["power_limit"] = lim / 1000.0 if lim is not None else None
|
||||
out["pcie_gen"] = self._uint("nvmlDeviceGetCurrPcieLinkGeneration") # drops at idle (power saving)
|
||||
out["pcie_gen_max"] = self._uint("nvmlDeviceGetMaxPcieLinkGeneration")
|
||||
out["pcie_width"] = self._uint("nvmlDeviceGetCurrPcieLinkWidth")
|
||||
rx = self._uint("nvmlDeviceGetPcieThroughput", ctypes.c_uint(1)) # NVML_PCIE_UTIL_RX_BYTES, KB/s
|
||||
tx = self._uint("nvmlDeviceGetPcieThroughput", ctypes.c_uint(0))
|
||||
out["pcie_rx_mb"] = rx / 1024.0 if rx is not None else None
|
||||
out["pcie_tx_mb"] = tx / 1024.0 if tx is not None else None
|
||||
return out
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------------------------ CPU / RAM
|
||||
def _cpu_name():
|
||||
if os.name == "nt":
|
||||
try:
|
||||
import winreg
|
||||
k = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"HARDWARE\DESCRIPTION\System\CentralProcessor\0")
|
||||
return winreg.QueryValueEx(k, "ProcessorNameString")[0].strip()
|
||||
except OSError:
|
||||
pass
|
||||
elif os.path.exists("/proc/cpuinfo"):
|
||||
for line in open("/proc/cpuinfo", encoding="utf-8", errors="replace"):
|
||||
if line.startswith("model name"):
|
||||
return line.split(":", 1)[1].strip()
|
||||
return platform.processor() or None
|
||||
|
||||
|
||||
class _CpuRamFallback:
|
||||
"""CPU load and RAM without psutil."""
|
||||
|
||||
def __init__(self):
|
||||
self.prev = self._times()
|
||||
|
||||
def _times(self):
|
||||
if os.name == "nt":
|
||||
idle, kern, user = (ctypes.c_ulonglong() for _ in range(3))
|
||||
if ctypes.windll.kernel32.GetSystemTimes(ctypes.byref(idle), ctypes.byref(kern), ctypes.byref(user)):
|
||||
return idle.value, kern.value + user.value # kernel time includes idle
|
||||
return None
|
||||
try:
|
||||
f = [int(x) for x in open("/proc/stat").readline().split()[1:]]
|
||||
return f[3] + f[4], sum(f)
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
|
||||
def cpu(self):
|
||||
cur = self._times()
|
||||
prev, self.prev = self.prev, cur
|
||||
if not cur or not prev or cur[1] == prev[1]:
|
||||
return None
|
||||
return max(0.0, min(100.0, 100.0 * (1 - (cur[0] - prev[0]) / (cur[1] - prev[1]))))
|
||||
|
||||
@staticmethod
|
||||
def ram():
|
||||
if os.name == "nt":
|
||||
class MS(ctypes.Structure):
|
||||
_fields_ = [("dwLength", ctypes.c_ulong), ("dwMemoryLoad", ctypes.c_ulong),
|
||||
("ullTotalPhys", ctypes.c_ulonglong), ("ullAvailPhys", ctypes.c_ulonglong),
|
||||
("ullTotalPageFile", ctypes.c_ulonglong), ("ullAvailPageFile", ctypes.c_ulonglong),
|
||||
("ullTotalVirtual", ctypes.c_ulonglong), ("ullAvailVirtual", ctypes.c_ulonglong),
|
||||
("ullAvailExtendedVirtual", ctypes.c_ulonglong)]
|
||||
m = MS()
|
||||
m.dwLength = ctypes.sizeof(MS)
|
||||
if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(m)):
|
||||
return m.ullTotalPhys - m.ullAvailPhys, m.ullTotalPhys
|
||||
return None, None
|
||||
try:
|
||||
info = dict(line.split(":", 1) for line in open("/proc/meminfo"))
|
||||
total = int(info["MemTotal"].split()[0]) * 1024
|
||||
avail = int(info["MemAvailable"].split()[0]) * 1024
|
||||
return total - avail, total
|
||||
except (OSError, KeyError, ValueError):
|
||||
return None, None
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------------------------ the sampler
|
||||
class Telemetry:
|
||||
def __init__(self, extra=None):
|
||||
"""`extra()` -> dict of more series to record each second (the server's tok/s)."""
|
||||
self.extra = extra
|
||||
self.lock = threading.Lock()
|
||||
self.now: dict = {}
|
||||
self.hist = collections.defaultdict(lambda: collections.deque(maxlen=HISTORY))
|
||||
self.gpu = _Nvml()
|
||||
try:
|
||||
import psutil # noqa: F401
|
||||
self.ps = sys.modules["psutil"]
|
||||
except ImportError:
|
||||
self.ps = None
|
||||
self.fallback = _CpuRamFallback()
|
||||
self.static = {
|
||||
"gpu_name": self.gpu.name() if self.gpu.ok() else None,
|
||||
"cpu_name": _cpu_name(),
|
||||
"cores": (self.ps.cpu_count(logical=False) if self.ps else None) or None,
|
||||
"threads": os.cpu_count(),
|
||||
"psutil": self.ps is not None,
|
||||
}
|
||||
self._disk_prev = None
|
||||
threading.Thread(target=self._loop, daemon=True).start()
|
||||
|
||||
def _disk(self):
|
||||
if not self.ps:
|
||||
return None, None
|
||||
try:
|
||||
c = self.ps.disk_io_counters()
|
||||
except (OSError, RuntimeError):
|
||||
return None, None
|
||||
t = time.time()
|
||||
prev, self._disk_prev = self._disk_prev, (t, c.read_bytes, c.write_bytes)
|
||||
if prev is None or t <= prev[0]:
|
||||
return None, None
|
||||
dt = t - prev[0]
|
||||
return (c.read_bytes - prev[1]) / dt / 2**20, (c.write_bytes - prev[2]) / dt / 2**20
|
||||
|
||||
def sample(self):
|
||||
s = {}
|
||||
if self.gpu.ok():
|
||||
g = self.gpu.read()
|
||||
s.update({f"gpu_{k}": v for k, v in g.items()})
|
||||
if self.ps:
|
||||
try:
|
||||
s["cpu"] = self.ps.cpu_percent(interval=None)
|
||||
vm = self.ps.virtual_memory()
|
||||
s["ram_used"], s["ram_total"] = vm.total - vm.available, vm.total
|
||||
except (OSError, RuntimeError):
|
||||
pass
|
||||
else:
|
||||
s["cpu"] = self.fallback.cpu()
|
||||
s["ram_used"], s["ram_total"] = self.fallback.ram()
|
||||
s["disk_read_mb"], s["disk_write_mb"] = self._disk()
|
||||
if self.extra:
|
||||
try:
|
||||
s.update(self.extra())
|
||||
except Exception: # noqa: BLE001 - telemetry must never take the server down
|
||||
pass
|
||||
return s
|
||||
|
||||
def _loop(self):
|
||||
while True:
|
||||
s = self.sample()
|
||||
with self.lock:
|
||||
self.now = s
|
||||
for k in ("gpu_util", "gpu_mem_used", "gpu_temp", "gpu_power", "gpu_pcie_rx_mb", "cpu", "ram_used",
|
||||
"disk_read_mb", "tok_s"):
|
||||
v = s.get(k)
|
||||
self.hist[k].append(round(v, 2) if isinstance(v, float) else v)
|
||||
time.sleep(1.0)
|
||||
|
||||
def snapshot(self):
|
||||
with self.lock:
|
||||
return {"now": dict(self.now), "history": {k: list(v) for k, v in self.hist.items()},
|
||||
"static": dict(self.static)}
|
||||
@@ -0,0 +1,233 @@
|
||||
"""serve/test_server.py - the max tokens budget over both APIs, against the mock engine (no GPU, no pack).
|
||||
|
||||
python -m unittest serve.test_server -v
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||||
from serve.frontend import ChatTemplate # noqa: E402
|
||||
from serve.server import CTX_SLACK, ByteTokenizer, MockEngine, Service, serve # noqa: E402
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
CTX = 4096
|
||||
ANSWER = "x" * 2000 # longer than the old 1024 fallback: one token per byte
|
||||
|
||||
|
||||
class RecordingEngine(MockEngine):
|
||||
def generate(self, ids, max_new, sampling, cancel, embeddings=None):
|
||||
self.last_max_new = max_new
|
||||
yield from super().generate(ids, max_new, sampling, cancel, embeddings)
|
||||
|
||||
|
||||
class MaxTokens(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
tok = ByteTokenizer()
|
||||
cls.engine = RecordingEngine(tok, "</think>\n\n" + ANSWER, max_context=CTX)
|
||||
cls.svc = Service(cls.engine, tok, ChatTemplate(ROOT / "serve/chat_template.jinja"))
|
||||
cls.httpd = serve(cls.svc, port=0)
|
||||
cls.base = f"http://127.0.0.1:{cls.httpd.server_address[1]}"
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.httpd.shutdown()
|
||||
cls.httpd.server_close()
|
||||
|
||||
def post(self, path, body):
|
||||
req = urllib.request.Request(self.base + path, data=json.dumps(body).encode(),
|
||||
headers={"Content-Type": "application/json"})
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=30) as r:
|
||||
return r.status, json.loads(r.read())
|
||||
except urllib.error.HTTPError as e:
|
||||
with e:
|
||||
return e.code, json.loads(e.read())
|
||||
|
||||
def call(self, api, text="hi", **budget):
|
||||
"""-> (status, body, prompt tokens, completion tokens); `budget` is merged into the request as given."""
|
||||
msgs = [{"role": "user", "content": text}]
|
||||
if api == "openai":
|
||||
s, b = self.post("/v1/chat/completions", {"model": "m", "messages": msgs, **budget})
|
||||
u = b.get("usage", {})
|
||||
return s, b, u.get("prompt_tokens"), u.get("completion_tokens")
|
||||
s, b = self.post("/v1/messages", {"model": "m", "messages": msgs, **budget})
|
||||
u = b.get("usage", {})
|
||||
return s, b, u.get("input_tokens"), u.get("output_tokens")
|
||||
|
||||
def test_unset_budget_is_the_rest_of_the_context(self):
|
||||
cases = {"openai": [{"max_tokens": -1}, {"max_tokens": 0}, {}, {"max_tokens": None},
|
||||
{"max_completion_tokens": -1}, {"max_completion_tokens": None, "max_tokens": None}],
|
||||
"anthropic": [{"max_tokens": -1}, {"max_tokens": 0}, {}, {"max_tokens": None}]}
|
||||
for api, budgets in cases.items():
|
||||
for budget in budgets:
|
||||
with self.subTest(api=api, budget=budget):
|
||||
s, b, pt, ct = self.call(api, **budget)
|
||||
self.assertEqual(s, 200, b)
|
||||
self.assertEqual(self.engine.last_max_new, CTX - CTX_SLACK - pt)
|
||||
self.assertGreater(ct, 1024) # the whole answer, not cut at the old 1024 fallback
|
||||
|
||||
def test_explicit_budget_is_honoured(self):
|
||||
for api, budget in [("openai", {"max_tokens": 50}), ("openai", {"max_completion_tokens": 50}),
|
||||
("openai", {"max_completion_tokens": 50, "max_tokens": 9}),
|
||||
("anthropic", {"max_tokens": 50}), ("openai", {"max_tokens": 1500}),
|
||||
("anthropic", {"max_tokens": 1500})]:
|
||||
with self.subTest(api=api, budget=budget):
|
||||
want = budget.get("max_completion_tokens") or budget["max_tokens"]
|
||||
s, b, _, ct = self.call(api, **budget)
|
||||
self.assertEqual(s, 200, b)
|
||||
self.assertEqual(self.engine.last_max_new, want)
|
||||
self.assertEqual(ct, want)
|
||||
|
||||
def test_explicit_budget_over_the_context_is_rejected(self):
|
||||
for api in ("openai", "anthropic"):
|
||||
with self.subTest(api=api):
|
||||
s, b, _, _ = self.call(api, max_tokens=CTX)
|
||||
self.assertEqual(s, 400)
|
||||
self.assertIn("exceeds the context", b["error"]["message"])
|
||||
|
||||
def test_unset_budget_with_a_near_full_prompt(self):
|
||||
_, _, pt0, _ = self.call("openai", max_tokens=1)
|
||||
overhead = pt0 - len("hi") # the template's tokens around the user text
|
||||
for api in ("openai", "anthropic"):
|
||||
_, _, pa, _ = self.call(api, max_tokens=1)
|
||||
over = pa - pt0 # the Anthropic template may differ slightly
|
||||
with self.subTest(api=api, room=5): # a few tokens left: the budget is exactly those
|
||||
text = "y" * (CTX - CTX_SLACK - overhead - over - 5)
|
||||
s, b, pt, ct = self.call(api, text=text, max_tokens=-1)
|
||||
self.assertEqual(s, 200, b)
|
||||
self.assertEqual(self.engine.last_max_new, 5)
|
||||
self.assertEqual(ct, 5)
|
||||
with self.subTest(api=api, room=0): # nothing left: rejected, not truncated
|
||||
text = "y" * (CTX - CTX_SLACK - overhead - over)
|
||||
s, b, _, _ = self.call(api, text=text)
|
||||
self.assertEqual(s, 400, b)
|
||||
self.assertIn("no room to answer", b["error"]["message"])
|
||||
|
||||
def test_debug_log_shows_the_resolved_budget(self):
|
||||
import contextlib
|
||||
import io
|
||||
os.environ["STRATA_DEBUG"] = "1"
|
||||
try:
|
||||
for api in ("openai", "anthropic"):
|
||||
with self.subTest(api=api):
|
||||
out = io.StringIO()
|
||||
with contextlib.redirect_stdout(out):
|
||||
_, _, pt, _ = self.call(api, max_tokens=-1)
|
||||
self.assertIn(f"max_new={CTX - CTX_SLACK - pt} ", out.getvalue())
|
||||
finally:
|
||||
del os.environ["STRATA_DEBUG"]
|
||||
|
||||
|
||||
class FitMaxTokens(unittest.TestCase):
|
||||
"""PR #24: --fit-max-tokens clamps an explicit budget that overshoots the context instead of a 400."""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
tok = ByteTokenizer()
|
||||
cls.engine = RecordingEngine(tok, "</think>\n\n" + ANSWER, max_context=CTX)
|
||||
cls.svc = Service(cls.engine, tok, ChatTemplate(ROOT / "serve/chat_template.jinja"), fit_max_tokens=True)
|
||||
cls.httpd = serve(cls.svc, port=0)
|
||||
cls.base = f"http://127.0.0.1:{cls.httpd.server_address[1]}"
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.httpd.shutdown()
|
||||
cls.httpd.server_close()
|
||||
|
||||
post = MaxTokens.post
|
||||
call = MaxTokens.call
|
||||
|
||||
def test_overshoot_is_clamped_to_the_room(self):
|
||||
for api in ("openai", "anthropic"):
|
||||
with self.subTest(api=api):
|
||||
s, b, pt, ct = self.call(api, max_tokens=CTX)
|
||||
self.assertEqual(s, 200, b)
|
||||
self.assertEqual(self.engine.last_max_new, CTX - CTX_SLACK - pt)
|
||||
|
||||
def test_a_budget_that_fits_is_unchanged(self):
|
||||
s, b, _, ct = self.call("openai", max_tokens=50)
|
||||
self.assertEqual(s, 200, b)
|
||||
self.assertEqual(self.engine.last_max_new, 50)
|
||||
|
||||
def test_no_room_is_still_a_400(self):
|
||||
_, _, pt0, _ = self.call("openai", max_tokens=1)
|
||||
overhead = pt0 - len("hi")
|
||||
s, b, _, _ = self.call("openai", text="y" * (CTX - CTX_SLACK - overhead), max_tokens=100)
|
||||
self.assertEqual(s, 400, b)
|
||||
self.assertIn("no room to answer", b["error"]["message"])
|
||||
|
||||
|
||||
class WebApp(unittest.TestCase):
|
||||
"""The web app (PR #22's dashboard idea, rebuilt): its page and files, and GET /metrics."""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
tok = ByteTokenizer()
|
||||
cls.svc = Service(RecordingEngine(tok, "</think>\n\nhello", max_context=CTX), tok,
|
||||
ChatTemplate(ROOT / "serve/chat_template.jinja"))
|
||||
cls.httpd = serve(cls.svc, port=0)
|
||||
cls.base = f"http://127.0.0.1:{cls.httpd.server_address[1]}"
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.httpd.shutdown()
|
||||
|
||||
def get(self, path, headers=None):
|
||||
req = urllib.request.Request(self.base + path, headers=headers or {})
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as r:
|
||||
return r.status, r.headers.get("Content-Type", ""), r.read()
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, e.headers.get("Content-Type", ""), e.read()
|
||||
|
||||
def test_page_and_files(self):
|
||||
code, ctype, body = self.get("/")
|
||||
self.assertEqual(code, 200)
|
||||
self.assertIn("text/html", ctype)
|
||||
self.assertIn(b"/web/app.js", body)
|
||||
for path, want in (("/web/app.js", "javascript"), ("/web/app.css", "text/css"), ("/web/tokens.css", "text/css"),
|
||||
("/web/components.css", "text/css"), ("/web/sprite.svg", "image/svg+xml")):
|
||||
with self.subTest(path=path):
|
||||
code, ctype, _ = self.get(path)
|
||||
self.assertEqual(code, 200)
|
||||
self.assertIn(want, ctype)
|
||||
|
||||
def test_only_the_app_files_are_served(self):
|
||||
for path in ("/web/..%2Fserver.py", "/web/index.html", "/web/test.py", "/fonts/..%2F..%2Fsetup.py",
|
||||
"/fonts/missing.woff2", "/fonts/x.ttf"):
|
||||
with self.subTest(path=path):
|
||||
self.assertEqual(self.get(path)[0], 404)
|
||||
|
||||
def test_metrics(self):
|
||||
data = json.dumps({"model": "m", "messages": [{"role": "user", "content": "hi"}], "max_tokens": 5}).encode()
|
||||
urllib.request.urlopen(urllib.request.Request(self.base + "/v1/chat/completions", data=data,
|
||||
headers={"Content-Type": "application/json"}), timeout=10).read()
|
||||
code, ctype, body = self.get("/metrics")
|
||||
self.assertEqual(code, 200)
|
||||
m = json.loads(body)
|
||||
for key in ("engine", "live", "requests", "hardware", "hardware_static", "history"):
|
||||
self.assertIn(key, m)
|
||||
self.assertEqual(m["engine"]["max_context"], CTX)
|
||||
self.assertEqual(m["live"]["state"], "idle")
|
||||
self.assertEqual(m["requests"][0]["output_tokens"], 5)
|
||||
|
||||
def test_metrics_need_the_key_when_one_is_set(self):
|
||||
self.svc.api_key = "secret"
|
||||
try:
|
||||
self.assertEqual(self.get("/metrics")[0], 401)
|
||||
self.assertEqual(self.get("/metrics", {"Authorization": "Bearer secret"})[0], 200)
|
||||
self.assertEqual(self.get("/")[0], 200) # the page itself asks for the key
|
||||
finally:
|
||||
self.svc.api_key = ""
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,140 @@
|
||||
/* Strata web app - layout on top of tokens.css + components.css (the Strata UI kit). Colours, type, radii and
|
||||
shadows come only from the kit's tokens. */
|
||||
[hidden] { display: none !important; }
|
||||
html, body { height: 100%; }
|
||||
body { display: flex; flex-direction: column; overflow: hidden; }
|
||||
main { flex: 1; min-height: 0; display: flex; }
|
||||
.view { flex: 1; min-height: 0; display: flex; flex-direction: column; }
|
||||
.view[hidden] { display: none; }
|
||||
.muted { color: var(--st-ink-muted); }
|
||||
.small { font-size: var(--st-fs-xs); }
|
||||
.card-title { font-weight: var(--st-fw-bold); font-size: var(--st-fs-base); color: var(--st-ink); }
|
||||
.st-header { position: relative; z-index: 2; flex: none; }
|
||||
.st-header .st-tabs { margin-left: var(--st-s-4); }
|
||||
#drawer-close .st-icon { transform: rotate(-90deg); }
|
||||
|
||||
/* ---------------------------------------------------------------- chat */
|
||||
.chat-scroll { flex: 1; min-height: 0; overflow-y: auto; }
|
||||
.chat { max-width: 860px; margin: 0 auto; padding: var(--st-s-8) var(--st-s-6) var(--st-s-6); display: flex;
|
||||
flex-direction: column; gap: var(--st-s-6); }
|
||||
.chat-empty { margin: 12vh auto 0; text-align: center; }
|
||||
.chat-empty__title { font-weight: var(--st-fw-black); font-size: var(--st-fs-display); line-height: var(--st-lh-tight);
|
||||
letter-spacing: -.02em; }
|
||||
.chat-empty__sub { margin-top: var(--st-s-3); color: var(--st-ink-muted); }
|
||||
.st-msg { width: 100%; }
|
||||
.st-msg--assistant { align-self: flex-start; }
|
||||
.st-msg--assistant .st-bubble { width: 100%; }
|
||||
.st-msg--user .st-bubble { white-space: pre-wrap; overflow-wrap: anywhere; }
|
||||
.st-bubble > :first-child { margin-top: 0; }
|
||||
.st-bubble > :last-child { margin-bottom: 0; }
|
||||
.st-bubble p, .st-bubble ul, .st-bubble ol { margin: 0 0 var(--st-s-3); }
|
||||
.st-bubble ul, .st-bubble ol { padding-left: var(--st-s-6); }
|
||||
.st-bubble li + li { margin-top: var(--st-s-1); }
|
||||
.st-bubble h3 { font-size: var(--st-fs-lg); margin: var(--st-s-4) 0 var(--st-s-2); color: var(--st-ink); }
|
||||
.st-bubble h4 { font-size: var(--st-fs-base); margin: var(--st-s-3) 0 var(--st-s-2); color: var(--st-ink); }
|
||||
.st-bubble code.inline { font: 400 .9em var(--st-font-mono); background: var(--st-surface-2); border: 1px solid var(--st-line-soft);
|
||||
border-radius: 6px; padding: 1px 5px; }
|
||||
.st-bubble .st-code { margin: var(--st-s-3) 0; }
|
||||
.st-bubble blockquote { margin: 0 0 var(--st-s-3); padding-left: var(--st-s-3); border-left: 3px solid var(--st-line);
|
||||
color: var(--st-ink-muted); }
|
||||
.st-bubble hr { border: 0; border-top: 1px solid var(--st-line); margin: var(--st-s-4) 0; }
|
||||
.st-bubble table { border-collapse: collapse; margin: 0 0 var(--st-s-3); font-size: var(--st-fs-md); }
|
||||
.st-bubble th, .st-bubble td { border: 1px solid var(--st-line); padding: 6px 10px; text-align: left; }
|
||||
.msg-images { display: flex; flex-wrap: wrap; gap: var(--st-s-2); justify-content: flex-end; }
|
||||
.msg-images img { max-width: 220px; max-height: 180px; border-radius: var(--st-r-md); border: 1px solid var(--st-line); }
|
||||
.st-msg .st-collapse { width: 100%; }
|
||||
.st-collapse__body.thinking { white-space: pre-wrap; overflow-wrap: anywhere; max-height: 420px; overflow-y: auto; }
|
||||
.st-msg__meta .st-btn--icon { width: 28px; height: 28px; }
|
||||
.st-msg__meta .st-btn--icon .st-icon { width: 16px; height: 16px; }
|
||||
.cursor::after { content: ""; display: inline-block; width: 8px; height: 1.1em; margin-left: 2px; vertical-align: -3px;
|
||||
border-radius: 2px; background: var(--st-accent); animation: blink 1s steps(2) infinite; }
|
||||
@keyframes blink { 50% { opacity: 0; } }
|
||||
.msg-error { color: var(--st-danger-text); background: var(--st-danger-tint); border-radius: var(--st-r-md); padding: 10px 14px;
|
||||
font-size: var(--st-fs-md); }
|
||||
|
||||
.composer-wrap { flex: none; padding: 0 var(--st-s-6) var(--st-s-6); }
|
||||
.st-composer { max-width: 860px; margin: 0 auto; }
|
||||
.st-composer textarea { max-height: 40vh; }
|
||||
.st-btn--send { width: 42px; padding: 0; }
|
||||
.composer-hint { font-size: var(--st-fs-xs); color: var(--st-ink-muted); margin-right: var(--st-s-2); font-variant-numeric: tabular-nums; }
|
||||
.attachments { display: flex; flex-wrap: wrap; gap: var(--st-s-2); padding: 2px 4px 0; }
|
||||
.chip { display: inline-flex; align-items: center; gap: 6px; height: 30px; padding: 0 6px 0 10px; border-radius: var(--st-r-pill);
|
||||
background: var(--st-surface-2); border: 1px solid var(--st-line); font-size: var(--st-fs-xs); color: var(--st-ink-soft); }
|
||||
.chip .st-btn--icon { width: 22px; height: 22px; border-radius: 50%; }
|
||||
.chip .st-btn--icon .st-icon { width: 14px; height: 14px; }
|
||||
|
||||
/* ---------------------------------------------------------------- monitor */
|
||||
.view--monitor, .view--about { overflow-y: auto; }
|
||||
.monitor, .about { max-width: 1240px; width: 100%; margin: 0 auto; padding: var(--st-s-6); display: flex; flex-direction: column;
|
||||
gap: var(--st-s-5); }
|
||||
.state-card { display: flex; flex-direction: column; gap: var(--st-s-3); }
|
||||
.state-card__head { display: flex; align-items: center; gap: var(--st-s-4); flex-wrap: wrap; }
|
||||
.badges { display: flex; gap: var(--st-s-2); flex-wrap: wrap; }
|
||||
.badges .st-badge { opacity: .38; transition: opacity var(--st-dur); }
|
||||
.badges .st-badge.on { opacity: 1; }
|
||||
.state-card__row { display: flex; justify-content: space-between; gap: var(--st-s-4); font-size: var(--st-fs-sm);
|
||||
font-weight: var(--st-fw-medium); font-variant-numeric: tabular-nums; }
|
||||
.metrics { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: var(--st-s-4); }
|
||||
.metric-card { padding: var(--st-s-4) var(--st-s-5); }
|
||||
.st-metric__value small { font-size: var(--st-fs-md); font-weight: var(--st-fw-medium); color: var(--st-ink-muted); margin-left: 4px; }
|
||||
.st-metric__sub { font-size: var(--st-fs-xs); color: var(--st-ink-muted); font-variant-numeric: tabular-nums; min-height: 1em; }
|
||||
.st-metric__spark { display: block; overflow: visible; }
|
||||
.st-metric__spark[data-tone="warn"] { color: var(--st-warn); }
|
||||
.st-metric__spark[data-tone="info"] { color: var(--st-info); }
|
||||
.monitor-row { display: grid; grid-template-columns: minmax(260px, 1fr) minmax(0, 2.4fr); gap: var(--st-s-4); }
|
||||
.ctx-card { display: flex; flex-direction: column; gap: var(--st-s-2); }
|
||||
.ctx-gauge { position: relative; width: 150px; height: 150px; margin: var(--st-s-2) auto var(--st-s-3); }
|
||||
.ctx-gauge .st-gauge { width: 150px; height: 150px; }
|
||||
.ctx-gauge .st-gauge__fill { transition: stroke-dasharray 400ms var(--st-ease); }
|
||||
.ctx-gauge__label { position: absolute; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center;
|
||||
font-size: var(--st-fs-xs); }
|
||||
.ctx-gauge__pct { font-weight: var(--st-fw-black); font-size: var(--st-fs-xl); line-height: 1.1; font-variant-numeric: tabular-nums; }
|
||||
.bar-row { display: flex; justify-content: space-between; font-size: var(--st-fs-sm); font-weight: var(--st-fw-medium);
|
||||
margin-top: var(--st-s-2); font-variant-numeric: tabular-nums; }
|
||||
.req-card { display: flex; flex-direction: column; gap: var(--st-s-3); min-width: 0; }
|
||||
.table-wrap { overflow-x: auto; }
|
||||
|
||||
/* ---------------------------------------------------------------- about */
|
||||
.about { max-width: 860px; }
|
||||
.about .st-card { display: flex; flex-direction: column; gap: var(--st-s-3); }
|
||||
.about p { margin: 0; }
|
||||
.facts { display: grid; grid-template-columns: minmax(140px, max-content) 1fr; gap: 10px var(--st-s-6); margin: 0; font-size: var(--st-fs-md); }
|
||||
.facts dt { color: var(--st-ink-muted); }
|
||||
.facts dd { margin: 0; color: var(--st-ink-soft); font-variant-numeric: tabular-nums; display: flex; align-items: center; gap: 6px;
|
||||
overflow-wrap: anywhere; }
|
||||
.facts dd code { font: 400 13px var(--st-font-mono); }
|
||||
.facts .st-btn--icon { width: 28px; height: 28px; }
|
||||
.facts .st-btn--icon .st-icon { width: 16px; height: 16px; }
|
||||
.toggle-row { display: flex; align-items: center; justify-content: space-between; gap: var(--st-s-4); font-size: var(--st-fs-sm);
|
||||
font-weight: var(--st-fw-medium); color: var(--st-ink-soft); }
|
||||
|
||||
/* ---------------------------------------------------------------- drawer */
|
||||
.st-drawer { z-index: 40; }
|
||||
.scrim { position: fixed; inset: 0; background: rgba(15, 23, 42, .18); z-index: 39; }
|
||||
.seg { display: grid; grid-template-columns: repeat(4, 1fr); gap: 4px; padding: 4px; background: var(--st-surface-2);
|
||||
border: 1px solid var(--st-line); border-radius: var(--st-r-md); }
|
||||
.seg button { height: 32px; border: 0; border-radius: 10px; background: transparent; color: var(--st-ink-muted);
|
||||
font: 500 var(--st-fs-sm)/1 var(--st-font); cursor: pointer; }
|
||||
.seg button[aria-checked="true"] { background: var(--st-surface); color: var(--st-ink); font-weight: var(--st-fw-bold);
|
||||
box-shadow: var(--st-sh-card); }
|
||||
.drawer-actions { display: grid; grid-template-columns: 1fr 1fr; gap: var(--st-s-3); margin-top: var(--st-s-2); }
|
||||
.st-toast { animation: toast-in 180ms var(--st-ease); }
|
||||
@keyframes toast-in { from { opacity: 0; transform: translateY(6px); } }
|
||||
|
||||
/* ---------------------------------------------------------------- narrow screens */
|
||||
@media (max-width: 1000px) {
|
||||
.metrics { grid-template-columns: repeat(2, minmax(0, 1fr)); }
|
||||
.monitor-row { grid-template-columns: 1fr; }
|
||||
}
|
||||
@media (max-width: 640px) {
|
||||
.st-header { padding: 0 var(--st-s-3); gap: var(--st-s-2); }
|
||||
.st-header .st-tabs { margin-left: 0; }
|
||||
.st-tab { padding: 0 10px; }
|
||||
.st-tab .st-icon { display: none; }
|
||||
#pill-text { display: none; }
|
||||
.chat { padding: var(--st-s-5) var(--st-s-4); }
|
||||
.composer-wrap { padding: 0 var(--st-s-3) var(--st-s-3); }
|
||||
.monitor, .about { padding: var(--st-s-4); }
|
||||
.facts { grid-template-columns: 1fr; gap: 2px; }
|
||||
.facts dd { margin-bottom: var(--st-s-2); }
|
||||
}
|
||||
@@ -0,0 +1,710 @@
|
||||
// serve/web/app.js - the Strata web app: Chat, Monitor, About. No framework, no network beyond this server.
|
||||
// The Monitor tab rebuilds PR #22's dashboard idea (code-martin) on the server's own /metrics.
|
||||
"use strict";
|
||||
|
||||
const $ = (id) => document.getElementById(id);
|
||||
const SPRITE = "/web/sprite.svg";
|
||||
const icon = (name, cls = "st-icon") => `<svg class="${cls}" aria-hidden="true"><use href="${SPRITE}#i-${name}"/></svg>`;
|
||||
const esc = (s) => String(s).replace(/[&<>"']/g, (c) => ({"&": "&", "<": "<", ">": ">", '"': """, "'": "'"}[c]));
|
||||
const fmt = (n, d = 0) => (n == null || Number.isNaN(n) ? "–" : Number(n).toLocaleString(undefined, {maximumFractionDigits: d, minimumFractionDigits: d}));
|
||||
const kfmt = (n) => (n == null ? "–" : n >= 1000 ? `${fmt(n / 1000, n >= 10000 ? 0 : 1)}k` : fmt(n));
|
||||
// a context size: 32768 -> "32K" (powers of two), else like kfmt
|
||||
const ctxfmt = (n) => (n && n % 1024 === 0 ? `${fmt(n / 1024)}K` : kfmt(n));
|
||||
const gb = (b, d = 1) => (b == null ? "–" : fmt(b / 1073741824, d)); // memory: binary GB, as Windows shows it
|
||||
|
||||
const store = {
|
||||
get(k, d) { try { const v = localStorage.getItem("strata." + k); return v === null ? d : JSON.parse(v); } catch (e) { return d; } },
|
||||
set(k, v) { try { localStorage.setItem("strata." + k, JSON.stringify(v)); } catch (e) { /* private mode: in memory only */ } },
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------ toasts
|
||||
function toast(kind, title, text = "", ms = 3500, action = null) {
|
||||
const names = {info: "info", success: "check", warn: "warning", error: "error"};
|
||||
const el = document.createElement("div");
|
||||
el.className = `st-toast st-toast--${kind}`;
|
||||
el.innerHTML = `${icon(names[kind] || "info")}<div><div class="st-toast__title"></div><div class="t-text"></div></div>`;
|
||||
el.querySelector(".st-toast__title").textContent = title;
|
||||
el.querySelector(".t-text").textContent = text;
|
||||
if (action) {
|
||||
const b = document.createElement("button");
|
||||
b.className = "st-btn st-btn--secondary";
|
||||
b.style.height = "32px";
|
||||
b.style.marginLeft = "auto";
|
||||
b.textContent = action.label;
|
||||
b.onclick = () => { action.run(); el.remove(); };
|
||||
el.appendChild(b);
|
||||
}
|
||||
$("toasts").appendChild(el);
|
||||
setTimeout(() => el.remove(), ms);
|
||||
}
|
||||
|
||||
async function copyText(text, btn) {
|
||||
try {
|
||||
await navigator.clipboard.writeText(text);
|
||||
} catch (e) { // http on another host: no async clipboard
|
||||
const ta = document.createElement("textarea");
|
||||
ta.value = text; document.body.appendChild(ta); ta.select(); document.execCommand("copy"); ta.remove();
|
||||
}
|
||||
if (btn) {
|
||||
const use = btn.querySelector("use");
|
||||
use.setAttribute("href", `${SPRITE}#i-check`);
|
||||
setTimeout(() => use.setAttribute("href", `${SPRITE}#i-copy`), 1500);
|
||||
}
|
||||
toast("success", "Copied to clipboard", "", 1800);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ theme and tabs
|
||||
// the system's theme until the user picks one (only a click is saved)
|
||||
function setTheme(t, save) {
|
||||
document.documentElement.dataset.theme = t;
|
||||
if (save) try { localStorage.setItem("strata.theme", t); } catch (e) { /* ignore */ }
|
||||
$("theme-icon").setAttribute("href", `${SPRITE}#i-${t === "dark" ? "sun" : "moon"}`);
|
||||
$("dark-toggle").setAttribute("aria-checked", String(t === "dark"));
|
||||
}
|
||||
const flipTheme = () => setTheme(document.documentElement.dataset.theme === "dark" ? "light" : "dark", true);
|
||||
$("theme-btn").onclick = flipTheme;
|
||||
$("dark-toggle").onclick = flipTheme;
|
||||
setTheme(document.documentElement.dataset.theme || "light", false);
|
||||
matchMedia("(prefers-color-scheme: dark)").addEventListener("change", (e) => {
|
||||
let saved = null;
|
||||
try { saved = localStorage.getItem("strata.theme"); } catch (err) { /* ignore */ }
|
||||
if (!saved) setTheme(e.matches ? "dark" : "light", false);
|
||||
});
|
||||
|
||||
let tab = "chat";
|
||||
function showTab(name) {
|
||||
tab = ["chat", "monitor", "about"].includes(name) ? name : "chat";
|
||||
for (const b of document.querySelectorAll(".st-tab")) b.setAttribute("aria-selected", String(b.dataset.tab === tab));
|
||||
for (const v of ["chat", "monitor", "about"]) $(`view-${v}`).hidden = v !== tab;
|
||||
if (location.hash.slice(1) !== tab) history.replaceState(null, "", tab === "chat" ? location.pathname : `#${tab}`);
|
||||
if (tab === "chat") $("input").focus();
|
||||
if (lastMetrics) render(lastMetrics);
|
||||
}
|
||||
for (const b of document.querySelectorAll(".st-tab")) b.onclick = () => showTab(b.dataset.tab);
|
||||
window.addEventListener("hashchange", () => showTab(location.hash.slice(1)));
|
||||
|
||||
// ------------------------------------------------------------------ server access
|
||||
function headers(json = false) {
|
||||
const h = {};
|
||||
const key = store.get("apikey", "");
|
||||
if (key) h.Authorization = "Bearer " + key;
|
||||
if (json) h["Content-Type"] = "application/json";
|
||||
return h;
|
||||
}
|
||||
$("api-key").value = store.get("apikey", "");
|
||||
$("api-key").onchange = () => { store.set("apikey", $("api-key").value.trim()); toast("success", "API key saved", "Kept in this browser only."); };
|
||||
|
||||
let health = {model: "strata", images: false, max_context: 0};
|
||||
async function loadHealth() {
|
||||
try {
|
||||
health = await (await fetch("/health")).json();
|
||||
$("attach-btn").hidden = !health.images;
|
||||
$("chat-empty-sub").textContent = `${health.model} runs on this PC. Nothing leaves it.`;
|
||||
} catch (e) {
|
||||
setTimeout(loadHealth, 2000);
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ Monitor
|
||||
const METRICS = [
|
||||
{key: "speed", label: "Speed", icon: "gauge", unit: "tok/s", series: "tok_s"},
|
||||
{key: "gpu", label: "GPU load", icon: "gpu", unit: "%", series: "gpu_util", max: 100},
|
||||
{key: "vram", label: "VRAM", icon: "layers", unit: "GB", series: "gpu_mem_used"},
|
||||
{key: "temp", label: "GPU temp", icon: "thermometer", unit: "°C", series: "gpu_temp", tone: "warn"},
|
||||
{key: "power", label: "Power", icon: "bolt", unit: "W", series: "gpu_power"},
|
||||
{key: "pcie", label: "PCIe", icon: "link", unit: "", series: "gpu_pcie_rx_mb", tone: "info"},
|
||||
{key: "cpu", label: "CPU", icon: "cpu", unit: "%", series: "cpu", max: 100},
|
||||
{key: "disk", label: "Disk read", icon: "disk", unit: "MB/s", series: "disk_read_mb", tone: "info"},
|
||||
];
|
||||
$("metrics").innerHTML = METRICS.map((m) => `
|
||||
<div class="st-card metric-card"><div class="st-metric">
|
||||
<span class="st-metric__label">${icon(m.icon, "st-icon st-icon--sm")}${esc(m.label)}</span>
|
||||
<span class="st-metric__value" id="mv-${m.key}">–</span>
|
||||
<span class="st-metric__sub" id="ms-${m.key}"></span>
|
||||
<svg class="st-metric__spark" id="sp-${m.key}" viewBox="0 0 100 32" preserveAspectRatio="none"${m.tone ? ` data-tone="${m.tone}"` : ""}>
|
||||
<path class="area" fill="currentColor" opacity=".12"/><path class="line" fill="none" stroke="currentColor"
|
||||
stroke-width="1.6" stroke-linejoin="round" stroke-linecap="round" vector-effect="non-scaling-stroke"/></svg>
|
||||
</div></div>`).join("");
|
||||
|
||||
function spark(id, values, max) {
|
||||
const svg = $(id);
|
||||
const v = (values || []).map((x) => (x == null ? 0 : x));
|
||||
if (v.length < 2) { svg.querySelector(".line").setAttribute("d", ""); svg.querySelector(".area").setAttribute("d", ""); return; }
|
||||
const top = Math.max(max || 0, ...v, 1e-9);
|
||||
const pts = v.map((x, i) => [(i / (v.length - 1)) * 100, 30 - (x / top) * 26]);
|
||||
const line = pts.map((p, i) => `${i ? "L" : "M"}${p[0].toFixed(2)},${p[1].toFixed(2)}`).join("");
|
||||
svg.querySelector(".line").setAttribute("d", line);
|
||||
svg.querySelector(".area").setAttribute("d", `${line}L100,32L0,32Z`);
|
||||
}
|
||||
function setMetric(key, value, unit, sub) {
|
||||
$(`mv-${key}`).innerHTML = value == null ? "–" : `${esc(value)}${unit ? `<small>${esc(unit)}</small>` : ""}`;
|
||||
$(`ms-${key}`).textContent = sub || "";
|
||||
}
|
||||
|
||||
let lastMetrics = null, metricsFailures = 0, keyWarned = false;
|
||||
async function poll() {
|
||||
try {
|
||||
const r = await fetch("/metrics", {headers: headers()});
|
||||
if (r.status === 401) {
|
||||
setPill("error", "API key needed");
|
||||
if (!keyWarned) { keyWarned = true; toast("warn", "API key needed", "This server needs a key: add it under About > Settings.", 6000); }
|
||||
} else if (r.ok) {
|
||||
lastMetrics = await r.json();
|
||||
metricsFailures = 0;
|
||||
render(lastMetrics);
|
||||
} else {
|
||||
throw new Error(`HTTP ${r.status}`);
|
||||
}
|
||||
} catch (e) {
|
||||
if (++metricsFailures === 3) setPill("error", "Server not reachable");
|
||||
}
|
||||
setTimeout(poll, 1000);
|
||||
}
|
||||
|
||||
function setPill(state, text) {
|
||||
$("pill").dataset.state = state === "error" ? "queued" : state;
|
||||
$("pill-text").textContent = text;
|
||||
}
|
||||
|
||||
function render(m) {
|
||||
const live = m.live || {}, hw = m.hardware || {}, st = m.hardware_static || {}, eng = m.engine || {}, h = m.history || {};
|
||||
const last = (m.requests || [])[0];
|
||||
// the header pill
|
||||
if (live.state === "reading") {
|
||||
const pct = live.prompt_total ? Math.round((100 * live.prompt_read) / live.prompt_total) : null;
|
||||
setPill("reading", pct != null ? `Reading prompt · ${pct}%` : "Reading prompt");
|
||||
} else if (live.state === "generating") {
|
||||
setPill("generating", `Generating · ${fmt(live.tok_s, 1)} tok/s`);
|
||||
} else {
|
||||
setPill("idle", "Idle");
|
||||
}
|
||||
if (live.queued > 0) setPill("queued", `${live.queued} queued`);
|
||||
if (tab === "monitor") renderMonitor(live, hw, st, eng, h, last, m.requests || []);
|
||||
if (tab === "about") renderAbout(eng, hw, st);
|
||||
}
|
||||
|
||||
function renderMonitor(live, hw, st, eng, h, last, requests) {
|
||||
// model state
|
||||
const on = live.queued > 0 ? "queued" : live.state;
|
||||
for (const b of document.querySelectorAll("#state-badges .st-badge")) b.classList.toggle("on", b.dataset.s === on || b.dataset.s === live.state);
|
||||
const prog = $("state-progress");
|
||||
let label = "Waiting for a request", detail = "", pct = 0;
|
||||
if (live.state === "reading") {
|
||||
label = "Reading prompt";
|
||||
prog.dataset.tone = "info";
|
||||
if (live.prompt_total) {
|
||||
pct = (100 * live.prompt_read) / live.prompt_total;
|
||||
detail = `${fmt(live.prompt_read)} / ${fmt(live.prompt_total)} tokens · ${fmt(pct)}%`;
|
||||
} else {
|
||||
detail = `${fmt(live.prompt_tokens)} tokens`;
|
||||
}
|
||||
} else if (live.state === "generating") {
|
||||
label = live.phase ? live.phase[0].toUpperCase() + live.phase.slice(1) : "Generating";
|
||||
delete prog.dataset.tone;
|
||||
pct = live.max_tokens ? Math.min(100, (100 * live.generated) / live.max_tokens) : 0;
|
||||
detail = `${fmt(live.generated)} tokens · ${fmt(live.tok_s, 1)} tok/s`;
|
||||
} else if (last) {
|
||||
delete prog.dataset.tone;
|
||||
detail = `last: ${fmt(last.output_tokens)} tokens${last.decode_tok_s ? ` at ${fmt(last.decode_tok_s, 1)} tok/s` : ""}`;
|
||||
}
|
||||
$("state-label").textContent = label;
|
||||
$("state-detail").textContent = detail;
|
||||
$("state-bar").style.width = `${pct}%`;
|
||||
|
||||
// the eight cards
|
||||
const speed = live.state === "generating" ? live.tok_s : last ? last.decode_tok_s : null;
|
||||
setMetric("speed", speed == null ? null : fmt(speed, 1), "tok/s", live.state === "generating" ? "now" : last ? "last request" : "");
|
||||
spark("sp-speed", h.tok_s);
|
||||
setMetric("gpu", hw.gpu_util == null ? null : fmt(hw.gpu_util), "%", st.gpu_name || "");
|
||||
spark("sp-gpu", h.gpu_util, 100);
|
||||
setMetric("vram", hw.gpu_mem_used == null ? null : gb(hw.gpu_mem_used), hw.gpu_mem_total ? `/ ${gb(hw.gpu_mem_total, 0)} GB` : "GB",
|
||||
eng.expert_slots ? `${fmt(eng.expert_slots)} experts cached` : "");
|
||||
spark("sp-vram", h.gpu_mem_used, hw.gpu_mem_total);
|
||||
setMetric("temp", hw.gpu_temp == null ? null : fmt(hw.gpu_temp), "°C", "");
|
||||
spark("sp-temp", h.gpu_temp, 90);
|
||||
setMetric("power", hw.gpu_power == null ? null : fmt(hw.gpu_power), "W", hw.gpu_power_limit ? `of ${fmt(hw.gpu_power_limit)} W limit` : "");
|
||||
spark("sp-power", h.gpu_power, hw.gpu_power_limit);
|
||||
const gen = hw.gpu_pcie_gen_max || hw.gpu_pcie_gen;
|
||||
setMetric("pcie", gen ? `Gen${gen}` : null, hw.gpu_pcie_width ? `x${hw.gpu_pcie_width}` : "",
|
||||
hw.gpu_pcie_rx_mb == null ? "" : `to GPU ${fmt(hw.gpu_pcie_rx_mb, hw.gpu_pcie_rx_mb < 10 ? 1 : 0)} MB/s` +
|
||||
(hw.gpu_pcie_gen && gen && hw.gpu_pcie_gen < gen ? ` · idle Gen${hw.gpu_pcie_gen}` : ""));
|
||||
spark("sp-pcie", h.gpu_pcie_rx_mb);
|
||||
setMetric("cpu", hw.cpu == null ? null : fmt(hw.cpu), "%", st.threads ? `${st.cores ? `${st.cores} cores · ` : ""}${st.threads} threads` : "");
|
||||
spark("sp-cpu", h.cpu, 100);
|
||||
if (hw.disk_read_mb == null) {
|
||||
setMetric("disk", null, "", st.psutil ? "" : "needs psutil (setup installs it)");
|
||||
} else {
|
||||
const big = hw.disk_read_mb >= 1000;
|
||||
setMetric("disk", big ? fmt(hw.disk_read_mb / 1024, 2) : fmt(hw.disk_read_mb, hw.disk_read_mb < 10 ? 1 : 0), big ? "GB/s" : "MB/s",
|
||||
hw.disk_write_mb == null ? "" : `write ${fmt(hw.disk_write_mb, 1)} MB/s`);
|
||||
}
|
||||
spark("sp-disk", h.disk_read_mb);
|
||||
|
||||
// context fill: the running request, else the last one
|
||||
const ctx = eng.max_context || 0;
|
||||
let used = 0;
|
||||
if (live.state !== "idle") used = (live.prompt_tokens || 0) + (live.generated || 0);
|
||||
else if (last) used = (last.prompt_tokens || 0) + (last.output_tokens || 0);
|
||||
const frac = ctx ? Math.min(1, used / ctx) : 0;
|
||||
$("ctx-fill").setAttribute("stroke-dasharray", `${(235.6 * frac).toFixed(1)} 314.2`);
|
||||
$("ctx-fill").style.opacity = 235.6 * frac >= 3 ? "1" : "0"; // a near-zero arc would draw just its round cap
|
||||
$("ctx-pct").textContent = `${Math.round(frac * 100)}%`;
|
||||
$("ctx-sub").textContent = ctx ? `${kfmt(used)} / ${ctxfmt(ctx)}` : "–";
|
||||
const cacheBytes = (eng.expert_cache_mib || 0) * 1048576;
|
||||
$("slots-text").textContent = eng.expert_slots ? `${fmt(eng.expert_slots)} · ${gb(cacheBytes)} GB` : "–";
|
||||
$("slots-bar").style.width = hw.gpu_mem_total ? `${Math.min(100, (100 * cacheBytes) / hw.gpu_mem_total)}%` : "0%";
|
||||
$("ram-text").textContent = hw.ram_total ? `${gb(hw.ram_used)} / ${gb(hw.ram_total, 0)} GB` : "–";
|
||||
const ramPct = hw.ram_total ? (100 * hw.ram_used) / hw.ram_total : 0;
|
||||
$("ram-bar").style.width = `${ramPct}%`;
|
||||
if (ramPct > 92) $("ram-progress").dataset.tone = "danger"; else delete $("ram-progress").dataset.tone;
|
||||
$("temp-text").textContent = hw.gpu_temp == null ? "–" : `${fmt(hw.gpu_temp)} °C`;
|
||||
$("temp-bar").style.width = hw.gpu_temp == null ? "0%" : `${Math.min(100, hw.gpu_temp)}%`;
|
||||
|
||||
// recent requests
|
||||
const body = $("req-body");
|
||||
if (!requests.length) {
|
||||
body.innerHTML = `<tr><td colspan="7" class="muted">No requests yet</td></tr>`;
|
||||
} else {
|
||||
const badge = {stop: ["", "Done"], length: ["", "Max tokens"], cancel: ["st-badge--queued", "Stopped"],
|
||||
disconnect: ["st-badge--queued", "Closed"], error: ["st-badge--error", "Error"]};
|
||||
body.innerHTML = requests.slice(0, 12).map((r) => {
|
||||
const [cls, text] = badge[r.finish] || ["", r.finish || "–"];
|
||||
const t = new Date(r.time * 1000).toLocaleTimeString([], {hour: "2-digit", minute: "2-digit", second: "2-digit"});
|
||||
const proj = r.projection == null ? "" : ` <span class="st-badge${r.projection ? " st-badge--reading" : ""}" title="experimental speed projection ${r.projection ? "on" : "off"}">${r.projection ? "ESP" : "stock"}</span>`;
|
||||
return `<tr><td>${esc(t)}</td><td><span class="st-badge ${cls}">${esc(text)}</span>${proj}</td><td class="num">${fmt(r.prompt_tokens)}</td>
|
||||
<td class="num">${fmt(r.reused)}</td><td class="num">${fmt(r.output_tokens)}</td><td class="num">${fmt(r.decode_tok_s, 1)}</td>
|
||||
<td class="num">${fmt(r.duration_s, 1)} s</td></tr>`;
|
||||
}).join("");
|
||||
}
|
||||
}
|
||||
|
||||
function facts(el, rows) {
|
||||
el.innerHTML = rows.filter((r) => r[1] != null && r[1] !== "").map(([k, v, copy]) =>
|
||||
`<dt>${esc(k)}</dt><dd>${copy ? `<code>${esc(v)}</code><button class="st-btn st-btn--icon" data-copy="${esc(v)}" aria-label="Copy">${icon("copy")}</button>` : esc(v)}</dd>`).join("");
|
||||
}
|
||||
// INFO cvec=project:4-44[:singleL] | add:A-B | 0
|
||||
function projectionText(c) {
|
||||
if (!c || c === "0" || c === 0) return null;
|
||||
const [mode, range, single] = String(c).split(":");
|
||||
const [a, b] = (range || "").split("-");
|
||||
return `${mode === "project" ? "Projection" : "Additive"} control vector on layers ${a}–${b}` +
|
||||
`${single ? ` (layer ${single.replace("single", "")}'s direction)` : ""}. Per chat in Sampling. Its package ` +
|
||||
"describes the vector as a refusal-direction projection; measure the speed yourself";
|
||||
}
|
||||
function renderAbout(eng, hw, st) {
|
||||
const kv = {int8: "8-bit", q4_0: "4-bit (Hadamard-rotated)", fp16: "16-bit"}[eng.kv] || eng.kv;
|
||||
facts($("facts-engine"), [
|
||||
["Model", eng.model],
|
||||
["Engine", eng.version ? `v${eng.version}` : "built from source"],
|
||||
["Context", eng.max_context ? `${fmt(eng.max_context)} tokens` : null],
|
||||
["KV cache", kv ? `${kv}${eng.kv_resident ? `, streamed: ${fmt(eng.kv_resident)} positions per layer in VRAM, the rest in RAM` : ", all in VRAM"}` : null],
|
||||
["Experts in VRAM", eng.expert_slots ? `${fmt(eng.expert_slots)} (${gb((eng.expert_cache_mib || 0) * 1048576)} GB)` : null],
|
||||
["Speculation", eng.spec ? `MTP drafts up to ${Math.max(0, (eng.mtp_max || eng.spec) - 1)} tokens${eng.lookup ? ", prompt lookup on" : ""}` : null],
|
||||
["Images", eng.images ? "on" : "off"],
|
||||
["Experimental speed projection", projectionText(eng.cvec)],
|
||||
]);
|
||||
facts($("facts-hw"), [
|
||||
["GPU", st.gpu_name ? `${st.gpu_name}${hw.gpu_mem_total ? `, ${gb(hw.gpu_mem_total, 0)} GB` : ""}` : "not readable (NVML)"],
|
||||
["CPU", st.cpu_name ? `${st.cpu_name}${st.threads ? `, ${st.threads} threads` : ""}` : null],
|
||||
["RAM", hw.ram_total ? `${gb(hw.ram_total, 0)} GB` : null],
|
||||
]);
|
||||
const base = location.origin;
|
||||
facts($("facts-api"), [
|
||||
["OpenAI base URL", `${base}/v1`, true],
|
||||
["Anthropic base URL", base, true],
|
||||
["Model name", eng.model, true],
|
||||
]);
|
||||
}
|
||||
document.addEventListener("click", (e) => {
|
||||
const b = e.target.closest("[data-copy]");
|
||||
if (b) copyText(b.dataset.copy, b);
|
||||
});
|
||||
|
||||
// ------------------------------------------------------------------ Markdown (escaped first, then formatted)
|
||||
function inline(s) {
|
||||
const codes = [];
|
||||
s = s.replace(/`([^`\n]+)`/g, (_, c) => { codes.push(c); return `\u0000${codes.length - 1}\u0000`; });
|
||||
s = esc(s)
|
||||
.replace(/\*\*([^*\n]+)\*\*/g, "<strong>$1</strong>")
|
||||
.replace(/(^|[^*\w])\*([^*\n]+)\*(?![*\w])/g, "$1<em>$2</em>")
|
||||
.replace(/\[([^\]\n]+)\]\((https?:\/\/[^)\s]+)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
|
||||
return s.replace(/\u0000(\d+)\u0000/g, (_, i) => `<code class="inline">${esc(codes[+i])}</code>`);
|
||||
}
|
||||
function codeBlock(lang, code) {
|
||||
return `<div class="st-code"><div class="st-code__head"><span>${esc(lang || "code")}</span>` +
|
||||
`<button class="st-btn st-btn--icon" data-code-copy aria-label="Copy code">${icon("copy")}</button></div>` +
|
||||
`<pre><code>${esc(code)}</code></pre></div>`;
|
||||
}
|
||||
function blocks(text) {
|
||||
const out = [], lines = text.split("\n");
|
||||
let para = [], list = null;
|
||||
const flushPara = () => { if (para.length) out.push(`<p>${para.map(inline).join("<br>")}</p>`); para = []; };
|
||||
const flushList = () => { if (list) out.push(`<${list.tag}>${list.items.map((i) => `<li>${inline(i)}</li>`).join("")}</${list.tag}>`); list = null; };
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const l = lines[i];
|
||||
let m;
|
||||
if (!l.trim()) { flushPara(); flushList(); continue; }
|
||||
if ((m = l.match(/^(#{1,6})\s+(.*)$/))) { flushPara(); flushList(); out.push(`<${m[1].length <= 2 ? "h3" : "h4"}>${inline(m[2])}</${m[1].length <= 2 ? "h3" : "h4"}>`); continue; }
|
||||
if (/^\s*([-*_])\s*\1\s*\1[\s\1]*$/.test(l)) { flushPara(); flushList(); out.push("<hr>"); continue; }
|
||||
if ((m = l.match(/^>\s?(.*)$/))) { flushPara(); flushList(); out.push(`<blockquote>${inline(m[1])}</blockquote>`); continue; }
|
||||
if (/^\s*\|.*\|\s*$/.test(l) && i + 1 < lines.length && /^\s*\|?[\s:-]+\|[\s|:-]*$/.test(lines[i + 1])) {
|
||||
flushPara(); flushList();
|
||||
const cells = (row) => row.trim().replace(/^\||\|$/g, "").split("|").map((c) => inline(c.trim()));
|
||||
let html = `<table><thead><tr>${cells(l).map((c) => `<th>${c}</th>`).join("")}</tr></thead><tbody>`;
|
||||
i += 2;
|
||||
while (i < lines.length && /^\s*\|.*\|\s*$/.test(lines[i])) html += `<tr>${cells(lines[i++]).map((c) => `<td>${c}</td>`).join("")}</tr>`;
|
||||
i--;
|
||||
out.push(html + "</tbody></table>");
|
||||
continue;
|
||||
}
|
||||
if ((m = l.match(/^\s*(?:[-*+]|(\d+)[.)])\s+(.*)$/))) {
|
||||
flushPara();
|
||||
const tag = m[1] ? "ol" : "ul";
|
||||
if (!list || list.tag !== tag) { flushList(); list = {tag, items: []}; }
|
||||
list.items.push(m[2]);
|
||||
continue;
|
||||
}
|
||||
if (list && /^\s{2,}\S/.test(l)) { list.items[list.items.length - 1] += " " + l.trim(); continue; }
|
||||
flushList();
|
||||
para.push(l);
|
||||
}
|
||||
flushPara(); flushList();
|
||||
return out.join("");
|
||||
}
|
||||
function markdown(text) {
|
||||
let html = "", rest = text;
|
||||
for (;;) {
|
||||
const m = rest.match(/(^|\n)```([^\n`]*)\n/);
|
||||
if (!m) { html += blocks(rest); break; }
|
||||
html += blocks(rest.slice(0, m.index));
|
||||
rest = rest.slice(m.index + m[0].length);
|
||||
const end = rest.match(/(^|\n)```[ \t]*(\n|$)/);
|
||||
if (!end) { html += codeBlock(m[2].trim(), rest); break; } // still streaming
|
||||
html += codeBlock(m[2].trim(), rest.slice(0, end.index));
|
||||
rest = rest.slice(end.index + end[0].length);
|
||||
}
|
||||
return html;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ Chat
|
||||
const DEFAULTS = {thinking: "high", temperature: 0.6, top_p: 0.95, top_k: 20, max: "", seed: "", show: true, esp: true};
|
||||
let settings = {...DEFAULTS, ...store.get("sampling", {})};
|
||||
let messages = store.get("chat", []);
|
||||
let attachments = []; // {name, url}
|
||||
let busy = null; // {controller, msg}
|
||||
|
||||
function saveChat() {
|
||||
store.set("chat", messages.map((m) => ({...m, images: (m.images || []).map((i) => ({name: i.name}))})));
|
||||
}
|
||||
function timeStr(t) { return new Date(t).toLocaleTimeString([], {hour: "2-digit", minute: "2-digit"}); }
|
||||
|
||||
function msgEl(m, i) {
|
||||
const el = document.createElement("div");
|
||||
el.className = `st-msg st-msg--${m.role}`;
|
||||
el.dataset.i = i;
|
||||
if (m.role === "user") {
|
||||
if (m.images && m.images.length) {
|
||||
const wrap = document.createElement("div");
|
||||
wrap.className = "msg-images";
|
||||
for (const im of m.images) {
|
||||
if (im.url) { const img = document.createElement("img"); img.src = im.url; img.alt = im.name || "image"; wrap.appendChild(img); }
|
||||
else { const c = document.createElement("span"); c.className = "chip"; c.innerHTML = icon("image", "st-icon st-icon--sm"); c.append(im.name || "image"); wrap.appendChild(c); }
|
||||
}
|
||||
el.appendChild(wrap);
|
||||
}
|
||||
const b = document.createElement("div");
|
||||
b.className = "st-bubble";
|
||||
b.textContent = m.text;
|
||||
el.appendChild(b);
|
||||
const meta = document.createElement("div");
|
||||
meta.className = "st-msg__meta";
|
||||
meta.textContent = `You · ${timeStr(m.time)}`;
|
||||
el.appendChild(meta);
|
||||
} else {
|
||||
el.innerHTML = `<details class="st-collapse" hidden><summary>${icon("thinking", "st-icon st-icon--sm")}<span class="think-title"></span>` +
|
||||
`${icon("chevron", "st-icon st-icon--sm st-chev")}</summary><div class="st-collapse__body thinking"></div></details>` +
|
||||
`<div class="st-bubble"></div><div class="st-msg__meta"><span class="meta-text"></span>` +
|
||||
`<button class="st-btn st-btn--icon" data-msg-copy aria-label="Copy the answer" title="Copy">${icon("copy")}</button></div>`;
|
||||
updateAssistant(el, m, false);
|
||||
}
|
||||
return el;
|
||||
}
|
||||
function updateAssistant(el, m, streaming) {
|
||||
const det = el.querySelector("details");
|
||||
if (m.reasoning) {
|
||||
det.hidden = false;
|
||||
const thinkingNow = streaming && !m.text;
|
||||
el.querySelector(".think-title").textContent = thinkingNow ? "Thinking…" :
|
||||
m.thinkSecs != null ? `Thought for ${fmt(m.thinkSecs, 1)} s` : "Thoughts";
|
||||
const body = el.querySelector(".thinking");
|
||||
if (det.open || thinkingNow) body.textContent = m.reasoning;
|
||||
else body.dataset.pending = "1";
|
||||
// open while it streams (if wanted), closed once the answer starts - unless the user toggled it themselves
|
||||
if (thinkingNow && settings.show && !det.dataset.touched && !det.open) { det._auto = true; det.open = true; }
|
||||
if (!thinkingNow && det.open && !det.dataset.touched) { det._auto = true; det.open = false; }
|
||||
}
|
||||
const bubble = el.querySelector(".st-bubble");
|
||||
if (m.error) {
|
||||
bubble.innerHTML = `<div class="msg-error"></div>`;
|
||||
bubble.firstChild.textContent = m.error;
|
||||
} else if (!m.text && streaming) {
|
||||
bubble.innerHTML = m.reasoning ? `<span class="muted cursor">Writing</span>` : `<span class="cursor"></span>`;
|
||||
} else {
|
||||
bubble.innerHTML = markdown(m.text || "");
|
||||
if (streaming) bubble.classList.add("cursor"); else bubble.classList.remove("cursor");
|
||||
}
|
||||
el.querySelector(".meta-text").textContent = m.meta || (streaming ? "" : m.stopped ? "Stopped" : "");
|
||||
el.querySelector("[data-msg-copy]").hidden = streaming || !m.text;
|
||||
}
|
||||
function renderChat() {
|
||||
const chat = $("chat");
|
||||
chat.querySelectorAll(".st-msg").forEach((e) => e.remove());
|
||||
$("chat-empty").hidden = messages.length > 0;
|
||||
messages.forEach((m, i) => chat.appendChild(msgEl(m, i)));
|
||||
scrollDown(true);
|
||||
}
|
||||
function nearBottom() { const s = $("chat-scroll"); return s.scrollHeight - s.scrollTop - s.clientHeight < 120; }
|
||||
function scrollDown(force) { const s = $("chat-scroll"); if (force || nearBottom()) s.scrollTop = s.scrollHeight; }
|
||||
|
||||
$("chat").addEventListener("click", (e) => {
|
||||
const cc = e.target.closest("[data-code-copy]");
|
||||
if (cc) { copyText(cc.closest(".st-code").querySelector("pre").textContent, cc); return; }
|
||||
const mc = e.target.closest("[data-msg-copy]");
|
||||
if (mc) { const i = +mc.closest(".st-msg").dataset.i; copyText(messages[i].text, mc); }
|
||||
});
|
||||
$("chat").addEventListener("toggle", (e) => {
|
||||
const d = e.target;
|
||||
if (d.tagName !== "DETAILS") return;
|
||||
if (d._auto) { d._auto = false; return; } // our own open/close, not the user's
|
||||
d.dataset.touched = "1";
|
||||
const body = d.querySelector(".thinking");
|
||||
if (d.open && body.dataset.pending) { body.textContent = messages[+d.closest(".st-msg").dataset.i].reasoning; delete body.dataset.pending; }
|
||||
}, true);
|
||||
|
||||
function apiMessages() {
|
||||
const out = [];
|
||||
for (const m of messages) {
|
||||
if (m.role === "user") {
|
||||
const imgs = (m.images || []).filter((i) => i.url);
|
||||
out.push({role: "user", content: imgs.length ? [{type: "text", text: m.text},
|
||||
...imgs.map((i) => ({type: "image_url", image_url: {url: i.url}}))] : m.text});
|
||||
} else if (m.text && !m.error) {
|
||||
out.push({role: "assistant", content: m.text});
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function setBusy(on) {
|
||||
$("stop-btn").hidden = !on;
|
||||
$("send-btn").disabled = on;
|
||||
$("composer-hint").textContent = on ? "" : "Shift+Enter: new line";
|
||||
}
|
||||
|
||||
async function send() {
|
||||
const text = $("input").value.trim();
|
||||
if ((!text && !attachments.length) || busy) return;
|
||||
messages.push({role: "user", text, images: attachments, time: Date.now()});
|
||||
attachments = [];
|
||||
renderAttachments();
|
||||
$("input").value = "";
|
||||
autosize();
|
||||
const m = {role: "assistant", text: "", reasoning: "", time: Date.now()};
|
||||
messages.push(m);
|
||||
renderChat();
|
||||
const el = $("chat").lastElementChild;
|
||||
const controller = new AbortController();
|
||||
busy = {controller, msg: m};
|
||||
setBusy(true);
|
||||
|
||||
const body = {model: health.model, messages: apiMessages(), stream: true,
|
||||
reasoning_effort: settings.thinking};
|
||||
if (settings.temperature > 0) {
|
||||
Object.assign(body, {temperature: +settings.temperature, top_p: +settings.top_p, top_k: +settings.top_k});
|
||||
} else {
|
||||
body.temperature = 0;
|
||||
}
|
||||
if (settings.seed) body.seed = +settings.seed;
|
||||
if (settings.max) body.max_tokens = +settings.max;
|
||||
if (projectionLoaded()) body.experimental_speed_projection = !!settings.esp;
|
||||
|
||||
let firstAt = null, thinkStart = null, usage = null, frame = 0;
|
||||
const paint = () => { frame = 0; updateAssistant(el, m, true); scrollDown(); };
|
||||
try {
|
||||
const r = await fetch("/v1/chat/completions", {method: "POST", headers: headers(true), body: JSON.stringify(body),
|
||||
signal: controller.signal});
|
||||
if (!r.ok) {
|
||||
let msg = `HTTP ${r.status}`;
|
||||
try { msg = (await r.json()).error.message || msg; } catch (e) { /* not json */ }
|
||||
if (r.status === 401) msg = "This server needs an API key: add it under About > Settings.";
|
||||
throw new Error(msg);
|
||||
}
|
||||
const reader = r.body.getReader(), dec = new TextDecoder();
|
||||
let buf = "";
|
||||
for (;;) {
|
||||
const {value, done} = await reader.read();
|
||||
if (done) break;
|
||||
buf += dec.decode(value, {stream: true});
|
||||
let nl;
|
||||
while ((nl = buf.indexOf("\n")) >= 0) {
|
||||
const line = buf.slice(0, nl).trim();
|
||||
buf = buf.slice(nl + 1);
|
||||
if (!line.startsWith("data:")) continue; // ": keep-alive" comments while a long prompt is read
|
||||
const data = line.slice(5).trim();
|
||||
if (data === "[DONE]") continue;
|
||||
let j;
|
||||
try { j = JSON.parse(data); } catch (e) { continue; }
|
||||
if (j.error) throw new Error(j.error.message || "the engine reported an error");
|
||||
if (j.usage) usage = j.usage;
|
||||
const d = (j.choices && j.choices[0] && j.choices[0].delta) || {};
|
||||
if (d.reasoning_content) { if (!firstAt) firstAt = performance.now(); if (!thinkStart) thinkStart = performance.now(); m.reasoning += d.reasoning_content; }
|
||||
if (d.content) {
|
||||
if (!firstAt) firstAt = performance.now();
|
||||
if (thinkStart && m.thinkSecs == null) m.thinkSecs = (performance.now() - thinkStart) / 1000;
|
||||
m.text += d.content;
|
||||
}
|
||||
if (!frame) frame = requestAnimationFrame(paint);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
if (e.name === "AbortError") m.stopped = true;
|
||||
else { m.error = e.message || String(e); toast("error", "The request failed", m.error, 6000); }
|
||||
}
|
||||
if (thinkStart && m.thinkSecs == null) m.thinkSecs = (performance.now() - thinkStart) / 1000;
|
||||
const n = usage ? usage.completion_tokens : null;
|
||||
if (n && firstAt) {
|
||||
const secs = (performance.now() - firstAt) / 1000;
|
||||
m.meta = `${fmt(n)} tokens${secs > 0.25 ? ` · ${fmt(n / secs, 1)} tok/s` : ""}${m.stopped ? " · stopped" : ""}` +
|
||||
(projectionLoaded() ? (settings.esp ? " · projection on" : " · projection off") : "");
|
||||
} else if (m.stopped) {
|
||||
m.meta = "Stopped";
|
||||
}
|
||||
busy = null;
|
||||
setBusy(false);
|
||||
if (frame) cancelAnimationFrame(frame);
|
||||
updateAssistant(el, m, false);
|
||||
saveChat();
|
||||
scrollDown();
|
||||
}
|
||||
|
||||
$("composer").onsubmit = (e) => { e.preventDefault(); send(); };
|
||||
$("stop-btn").onclick = () => { if (busy) busy.controller.abort(); };
|
||||
$("input").addEventListener("keydown", (e) => {
|
||||
if (e.key === "Enter" && !e.shiftKey && !e.isComposing) { e.preventDefault(); send(); }
|
||||
});
|
||||
function autosize() { const t = $("input"); t.style.height = "auto"; t.style.height = `${Math.min(t.scrollHeight, innerHeight * 0.4)}px`; }
|
||||
$("input").addEventListener("input", autosize);
|
||||
|
||||
$("new-btn").onclick = () => {
|
||||
if (busy) { toast("warn", "Still writing", "Stop the answer first."); return; }
|
||||
if (!messages.length) return;
|
||||
const backup = messages;
|
||||
messages = [];
|
||||
saveChat();
|
||||
renderChat();
|
||||
toast("info", "New chat", "The last one was cleared.", 6000, {label: "Undo", run: () => { messages = backup; saveChat(); renderChat(); }});
|
||||
};
|
||||
$("export-btn").onclick = () => {
|
||||
if (!messages.length) { toast("info", "Nothing to save yet"); return; }
|
||||
const md = messages.map((m) => m.role === "user" ? `## You\n\n${m.text}\n` :
|
||||
`## ${health.model}\n\n${m.reasoning ? `<details><summary>Thinking</summary>\n\n${m.reasoning}\n\n</details>\n\n` : ""}${m.text || m.error || ""}\n`).join("\n");
|
||||
const a = document.createElement("a");
|
||||
a.href = URL.createObjectURL(new Blob([md], {type: "text/markdown"}));
|
||||
a.download = `strata-chat-${new Date().toISOString().slice(0, 16).replace(/[:T]/g, "-")}.md`;
|
||||
a.click();
|
||||
setTimeout(() => URL.revokeObjectURL(a.href), 5000);
|
||||
};
|
||||
|
||||
// pictures: the attach button, or paste into the message box
|
||||
function addFiles(files) {
|
||||
for (const f of files) {
|
||||
if (!f.type.startsWith("image/")) continue;
|
||||
if (f.size > 20e6) { toast("warn", "Picture too large", `${f.name} is over 20 MB.`); continue; }
|
||||
const r = new FileReader();
|
||||
r.onload = () => { attachments.push({name: f.name || "pasted image", url: r.result}); renderAttachments(); };
|
||||
r.readAsDataURL(f);
|
||||
}
|
||||
}
|
||||
function renderAttachments() {
|
||||
const box = $("attachments");
|
||||
box.hidden = !attachments.length;
|
||||
box.innerHTML = "";
|
||||
attachments.forEach((a, i) => {
|
||||
const c = document.createElement("span");
|
||||
c.className = "chip";
|
||||
c.innerHTML = icon("image", "st-icon st-icon--sm");
|
||||
c.append(a.name);
|
||||
const x = document.createElement("button");
|
||||
x.type = "button"; x.className = "st-btn st-btn--icon"; x.setAttribute("aria-label", "Remove");
|
||||
x.innerHTML = icon("trash");
|
||||
x.onclick = () => { attachments.splice(i, 1); renderAttachments(); };
|
||||
c.appendChild(x);
|
||||
box.appendChild(c);
|
||||
});
|
||||
}
|
||||
$("attach-btn").onclick = () => $("file").click();
|
||||
$("file").onchange = () => { addFiles($("file").files); $("file").value = ""; };
|
||||
$("input").addEventListener("paste", (e) => {
|
||||
if (!health.images) return;
|
||||
const files = [...(e.clipboardData || {}).files || []].filter((f) => f.type.startsWith("image/"));
|
||||
if (files.length) { e.preventDefault(); addFiles(files); }
|
||||
});
|
||||
|
||||
// ------------------------------------------------------------------ the sampling drawer
|
||||
function openDrawer(open) {
|
||||
$("drawer").dataset.open = String(open);
|
||||
$("drawer").setAttribute("aria-hidden", String(!open));
|
||||
$("scrim").hidden = !open;
|
||||
if (open) loadDrawer();
|
||||
}
|
||||
function loadDrawer(s = settings) {
|
||||
for (const b of $("s-thinking").children) b.setAttribute("aria-checked", String(b.dataset.v === s.thinking));
|
||||
$("s-temp").value = s.temperature; $("s-topp").value = s.top_p; $("s-topk").value = s.top_k;
|
||||
$("s-max").value = s.max; $("s-seed").value = s.seed;
|
||||
$("s-show").setAttribute("aria-checked", String(!!s.show));
|
||||
$("s-esp").setAttribute("aria-checked", String(s.esp !== false));
|
||||
$("esp-row").hidden = !projectionLoaded();
|
||||
outputs();
|
||||
}
|
||||
// the engine was started with the experimental-speed-projection control vector (INFO cvec=...)
|
||||
function projectionLoaded() {
|
||||
const c = lastMetrics && lastMetrics.engine ? lastMetrics.engine.cvec : 0;
|
||||
return !!c && c !== "0";
|
||||
}
|
||||
function outputs() {
|
||||
const t = +$("s-temp").value;
|
||||
$("o-temp").textContent = t === 0 ? "0 · greedy" : t.toFixed(2);
|
||||
$("o-topp").textContent = (+$("s-topp").value).toFixed(2);
|
||||
$("o-topk").textContent = $("s-topk").value;
|
||||
const sel = [...$("s-thinking").children].find((b) => b.getAttribute("aria-checked") === "true");
|
||||
$("o-thinking").textContent = sel ? {none: "answers right away", low: "short", medium: "medium", high: "thorough (default)"}[sel.dataset.v] : "";
|
||||
for (const id of ["s-topp", "s-topk"]) $(id).disabled = t === 0;
|
||||
}
|
||||
for (const b of $("s-thinking").children) b.onclick = () => { for (const x of $("s-thinking").children) x.setAttribute("aria-checked", String(x === b)); outputs(); };
|
||||
for (const id of ["s-temp", "s-topp", "s-topk"]) $(id).oninput = outputs;
|
||||
$("s-show").onclick = () => $("s-show").setAttribute("aria-checked", String($("s-show").getAttribute("aria-checked") !== "true"));
|
||||
$("s-esp").onclick = () => $("s-esp").setAttribute("aria-checked", String($("s-esp").getAttribute("aria-checked") !== "true"));
|
||||
$("s-reset").onclick = () => loadDrawer(DEFAULTS);
|
||||
$("s-apply").onclick = () => {
|
||||
const sel = [...$("s-thinking").children].find((b) => b.getAttribute("aria-checked") === "true");
|
||||
settings = {thinking: sel ? sel.dataset.v : "high", temperature: +$("s-temp").value, top_p: +$("s-topp").value,
|
||||
top_k: +$("s-topk").value, max: $("s-max").value.trim(), seed: $("s-seed").value.trim(),
|
||||
show: $("s-show").getAttribute("aria-checked") === "true",
|
||||
esp: $("s-esp").getAttribute("aria-checked") === "true"};
|
||||
store.set("sampling", settings);
|
||||
openDrawer(false);
|
||||
toast("success", "Sampling saved", settings.temperature === 0 ? "Greedy: the same question gives the same answer." : "");
|
||||
};
|
||||
$("sampling-btn").onclick = () => openDrawer(true);
|
||||
$("drawer-close").onclick = () => openDrawer(false);
|
||||
$("scrim").onclick = () => openDrawer(false);
|
||||
document.addEventListener("keydown", (e) => { if (e.key === "Escape" && $("drawer").dataset.open === "true") openDrawer(false); });
|
||||
|
||||
// ------------------------------------------------------------------ start
|
||||
setBusy(false);
|
||||
renderChat();
|
||||
const startQuestion = new URLSearchParams(location.search).get("q"); // /?q=... starts a chat (a shortcut)
|
||||
if (startQuestion) history.replaceState(null, "", location.pathname + location.hash);
|
||||
loadHealth().then(() => { if (startQuestion) { $("input").value = startQuestion; send(); } });
|
||||
showTab(location.hash.slice(1) || "chat");
|
||||
poll();
|
||||
@@ -0,0 +1,128 @@
|
||||
/* Strata UI — components. Requires tokens.css. */
|
||||
*,*::before,*::after{box-sizing:border-box}
|
||||
html,body{margin:0;background:var(--st-bg);color:var(--st-ink);font-family:var(--st-font);font-size:var(--st-fs-base);line-height:var(--st-lh-body);-webkit-font-smoothing:antialiased}
|
||||
a{color:var(--st-accent-text);text-decoration:none} a:hover{text-decoration:underline}
|
||||
:focus-visible{outline:2px solid var(--st-focus);outline-offset:2px}
|
||||
|
||||
/* icon — <svg class="st-icon"><use href="icons/sprite.svg#i-chat"/></svg> */
|
||||
.st-icon{width:20px;height:20px;flex:none;color:inherit}
|
||||
.st-icon--sm{width:16px;height:16px} .st-icon--lg{width:24px;height:24px}
|
||||
|
||||
/* header */
|
||||
.st-header{display:flex;align-items:center;gap:var(--st-s-4);height:60px;padding:0 var(--st-s-6);background:var(--st-surface);border-bottom:1px solid var(--st-line)}
|
||||
.st-header__brand{font-weight:900;font-size:var(--st-fs-lg);letter-spacing:-.01em}
|
||||
.st-header__spacer{flex:1}
|
||||
|
||||
/* status pill */
|
||||
.st-pill{display:inline-flex;align-items:center;gap:8px;height:30px;padding:0 12px;border-radius:var(--st-r-pill);border:1px solid var(--st-line);background:var(--st-surface-2);font-size:var(--st-fs-sm);font-weight:500;color:var(--st-ink-soft);font-variant-numeric:tabular-nums}
|
||||
.st-pill__dot{width:8px;height:8px;border-radius:50%;background:var(--st-ink-muted)}
|
||||
.st-pill[data-state="generating"] .st-pill__dot{background:var(--st-accent);box-shadow:0 0 0 4px var(--st-accent-tint)}
|
||||
.st-pill[data-state="reading"] .st-pill__dot{background:var(--st-info);box-shadow:0 0 0 4px var(--st-info-tint)}
|
||||
.st-pill[data-state="queued"] .st-pill__dot{background:var(--st-warn)}
|
||||
|
||||
/* tabs */
|
||||
.st-tabs{display:flex;gap:4px;padding:4px;background:var(--st-surface-2);border:1px solid var(--st-line);border-radius:var(--st-r-md)}
|
||||
.st-tab{display:inline-flex;align-items:center;gap:8px;height:36px;padding:0 14px;border:0;border-radius:10px;background:transparent;color:var(--st-ink-muted);font:500 var(--st-fs-md)/1 var(--st-font);cursor:pointer}
|
||||
.st-tab:hover{color:var(--st-ink)}
|
||||
.st-tab[aria-selected="true"]{background:var(--st-surface);color:var(--st-ink);font-weight:700;box-shadow:var(--st-sh-card)}
|
||||
|
||||
/* card + metric */
|
||||
.st-card{background:var(--st-surface);border:1px solid var(--st-line);border-radius:var(--st-r-lg);box-shadow:var(--st-sh-card);padding:var(--st-s-5)}
|
||||
.st-metric{display:flex;flex-direction:column;gap:10px}
|
||||
.st-metric__label{display:flex;align-items:center;gap:8px;font-size:var(--st-fs-sm);font-weight:500;color:var(--st-ink-muted)}
|
||||
.st-metric__value{font-weight:900;font-size:var(--st-fs-stat);line-height:1;letter-spacing:-.01em;font-variant-numeric:tabular-nums}
|
||||
.st-metric__unit{font-weight:500;font-size:var(--st-fs-md);color:var(--st-ink-muted);margin-left:4px}
|
||||
.st-metric__spark{width:100%;height:32px;color:var(--st-accent)}
|
||||
|
||||
/* progress + gauge */
|
||||
.st-progress{height:8px;border-radius:var(--st-r-pill);background:var(--st-surface-2);border:1px solid var(--st-line-soft);overflow:hidden}
|
||||
.st-progress__bar{height:100%;border-radius:inherit;background:var(--st-accent);transition:width var(--st-dur) var(--st-ease)}
|
||||
.st-progress[data-tone="info"] .st-progress__bar{background:var(--st-info)}
|
||||
.st-progress[data-tone="warn"] .st-progress__bar{background:var(--st-warn)}
|
||||
.st-progress[data-tone="danger"] .st-progress__bar{background:var(--st-danger)}
|
||||
/* gauge: see README for SVG markup (stroke-dasharray on a 270° arc) */
|
||||
.st-gauge{position:relative;width:120px;height:120px}
|
||||
.st-gauge__track{stroke:var(--st-surface-2)} .st-gauge__fill{stroke:var(--st-accent)}
|
||||
|
||||
/* table */
|
||||
.st-table{width:100%;border-collapse:collapse;font-size:var(--st-fs-md);font-variant-numeric:tabular-nums}
|
||||
.st-table th{text-align:left;font-weight:500;font-size:var(--st-fs-xs);letter-spacing:.04em;text-transform:uppercase;color:var(--st-ink-muted);padding:10px 12px;border-bottom:1px solid var(--st-line)}
|
||||
.st-table td{padding:12px;border-bottom:1px solid var(--st-line-soft);color:var(--st-ink-soft)}
|
||||
.st-table tr:hover td{background:var(--st-surface-2)}
|
||||
.st-table .num{text-align:right}
|
||||
|
||||
/* badges */
|
||||
.st-badge{display:inline-flex;align-items:center;gap:6px;height:24px;padding:0 10px;border-radius:var(--st-r-pill);font-size:var(--st-fs-xs);font-weight:700;background:var(--st-surface-2);color:var(--st-ink-muted);border:1px solid var(--st-line)}
|
||||
.st-badge::before{content:"";width:6px;height:6px;border-radius:50%;background:currentColor}
|
||||
.st-badge--reading{background:var(--st-info-tint);color:var(--st-info-text);border-color:transparent}
|
||||
.st-badge--generating{background:var(--st-accent-tint);color:var(--st-accent-text);border-color:transparent}
|
||||
.st-badge--queued{background:var(--st-warn-tint);color:var(--st-warn-text);border-color:transparent}
|
||||
.st-badge--error{background:var(--st-danger-tint);color:var(--st-danger-text);border-color:transparent}
|
||||
|
||||
/* chat */
|
||||
.st-msg{display:flex;flex-direction:column;gap:6px;max-width:720px}
|
||||
.st-msg--user{align-self:flex-end;align-items:flex-end}
|
||||
.st-bubble{padding:12px 16px;border-radius:var(--st-r-lg);font-size:var(--st-fs-base);line-height:1.55;color:var(--st-ink-soft)}
|
||||
.st-msg--user .st-bubble{background:var(--st-accent);color:var(--st-accent-ink);border-bottom-right-radius:6px}
|
||||
.st-msg--assistant .st-bubble{background:var(--st-surface);border:1px solid var(--st-line);border-bottom-left-radius:6px}
|
||||
.st-msg__meta{font-size:var(--st-fs-xs);color:var(--st-ink-muted);display:flex;gap:8px;align-items:center}
|
||||
|
||||
/* collapsible — <details class="st-collapse"><summary>…</summary><div class="st-collapse__body">…</div></details> */
|
||||
.st-collapse{border:1px solid var(--st-line);border-radius:var(--st-r-md);background:var(--st-surface-2)}
|
||||
.st-collapse>summary{list-style:none;display:flex;align-items:center;gap:8px;padding:10px 14px;cursor:pointer;font-size:var(--st-fs-sm);font-weight:500;color:var(--st-ink-muted)}
|
||||
.st-collapse>summary::-webkit-details-marker{display:none}
|
||||
.st-collapse>summary .st-chev{margin-left:auto;transition:transform var(--st-dur) var(--st-ease)}
|
||||
.st-collapse[open]>summary .st-chev{transform:rotate(180deg)}
|
||||
.st-collapse__body{padding:0 14px 14px;font-size:var(--st-fs-sm);color:var(--st-ink-muted);line-height:1.6}
|
||||
|
||||
/* code */
|
||||
.st-code{border-radius:var(--st-r-md);background:var(--st-code-bg);color:var(--st-code-ink);overflow:hidden}
|
||||
.st-code__head{display:flex;align-items:center;justify-content:space-between;padding:8px 8px 8px 14px;font:500 var(--st-fs-xs)/1 var(--st-font);color:#9aa3ab;border-bottom:1px solid rgba(255,255,255,.06)}
|
||||
.st-code pre{margin:0;padding:14px;overflow:auto;font:400 13px/1.6 var(--st-font-mono)}
|
||||
.st-code .st-btn--icon{color:#9aa3ab} .st-code .st-btn--icon:hover{background:rgba(255,255,255,.08);color:#fff}
|
||||
|
||||
/* composer */
|
||||
.st-composer{display:flex;flex-direction:column;gap:8px;padding:10px;background:var(--st-surface);border:1px solid var(--st-line);border-radius:var(--st-r-lg);box-shadow:var(--st-sh-bar)}
|
||||
.st-composer:focus-within{border-color:var(--st-focus)}
|
||||
.st-composer textarea{border:0;outline:0;resize:none;background:transparent;color:var(--st-ink);font:400 var(--st-fs-base)/1.5 var(--st-font);padding:6px 8px;min-height:48px}
|
||||
.st-composer__bar{display:flex;align-items:center;gap:6px}
|
||||
.st-composer__bar .spacer{flex:1}
|
||||
|
||||
/* drawer */
|
||||
.st-drawer{position:fixed;top:0;right:0;bottom:0;width:360px;max-width:100vw;background:var(--st-surface);border-left:1px solid var(--st-line);box-shadow:var(--st-sh-pop);display:flex;flex-direction:column;transform:translateX(100%);transition:transform 220ms var(--st-ease)}
|
||||
.st-drawer[data-open="true"]{transform:none}
|
||||
.st-drawer__head{display:flex;align-items:center;justify-content:space-between;padding:18px 20px;border-bottom:1px solid var(--st-line)}
|
||||
.st-drawer__body{padding:20px;display:flex;flex-direction:column;gap:22px;overflow:auto}
|
||||
|
||||
/* buttons */
|
||||
.st-btn{display:inline-flex;align-items:center;justify-content:center;gap:8px;height:42px;padding:0 18px;border-radius:var(--st-r-md);border:0;font:700 var(--st-fs-md)/1 var(--st-font);cursor:pointer;transition:background var(--st-dur),transform 120ms}
|
||||
.st-btn:active{transform:translateY(1px)}
|
||||
.st-btn--primary{background:var(--st-accent);color:var(--st-accent-ink);box-shadow:0 6px 16px rgba(16,185,129,.24),inset 0 1px 0 rgba(255,255,255,.18)}
|
||||
.st-btn--primary:hover{background:var(--st-accent-hover)}
|
||||
.st-btn--secondary{background:transparent;color:var(--st-ink);border:1.5px solid var(--st-line)}
|
||||
.st-btn--secondary:hover{background:var(--st-surface-2)}
|
||||
.st-btn--danger{background:var(--st-danger-tint);color:var(--st-danger-text)}
|
||||
.st-btn--icon{width:36px;height:36px;padding:0;border-radius:10px;background:transparent;color:var(--st-ink-muted)}
|
||||
.st-btn--icon:hover{background:var(--st-surface-2);color:var(--st-ink)}
|
||||
.st-btn:disabled{opacity:.45;cursor:not-allowed}
|
||||
|
||||
/* form controls */
|
||||
.st-field{display:flex;flex-direction:column;gap:8px}
|
||||
.st-label{display:flex;justify-content:space-between;font-size:var(--st-fs-sm);font-weight:500;color:var(--st-ink-soft)}
|
||||
.st-label output{font-variant-numeric:tabular-nums;color:var(--st-ink-muted)}
|
||||
.st-input{height:44px;padding:0 14px;border-radius:var(--st-r-md);border:1.5px solid var(--st-line);background:var(--st-surface);color:var(--st-ink);font:400 var(--st-fs-md) var(--st-font)}
|
||||
.st-input:focus{outline:0;border-color:var(--st-focus);box-shadow:0 0 0 3px color-mix(in srgb,var(--st-focus) 20%,transparent)}
|
||||
.st-slider{width:100%;accent-color:var(--st-accent)}
|
||||
.st-toggle{position:relative;width:40px;height:24px;border-radius:var(--st-r-pill);border:0;background:var(--st-line);cursor:pointer;transition:background var(--st-dur)}
|
||||
.st-toggle::after{content:"";position:absolute;top:3px;left:3px;width:18px;height:18px;border-radius:50%;background:#fff;box-shadow:0 1px 2px rgba(0,0,0,.2);transition:transform var(--st-dur) var(--st-ease)}
|
||||
.st-toggle[aria-checked="true"]{background:var(--st-accent)}
|
||||
.st-toggle[aria-checked="true"]::after{transform:translateX(16px)}
|
||||
|
||||
/* toast / alert */
|
||||
.st-toast{display:flex;align-items:flex-start;gap:12px;padding:14px 16px;border-radius:var(--st-r-md);background:var(--st-surface);border:1px solid var(--st-line);box-shadow:var(--st-sh-pop);font-size:var(--st-fs-md);color:var(--st-ink-soft);max-width:420px}
|
||||
.st-toast__title{font-weight:700;color:var(--st-ink)}
|
||||
.st-toast--info .st-icon{color:var(--st-info)}
|
||||
.st-toast--success .st-icon{color:var(--st-accent)}
|
||||
.st-toast--warn .st-icon{color:var(--st-warn)}
|
||||
.st-toast--error .st-icon{color:var(--st-danger)}
|
||||
.st-toasts{position:fixed;right:20px;bottom:20px;display:flex;flex-direction:column;gap:10px;z-index:50}
|
||||
@@ -0,0 +1,93 @@
|
||||
Copyright 2021 The Outfit Project Authors (https://github.com/Outfitio/Outfit-Fonts)
|
||||
|
||||
This Font Software is licensed under the SIL Open Font License, Version 1.1.
|
||||
This license is copied below, and is also available with a FAQ at:
|
||||
https://scripts.sil.org/OFL
|
||||
|
||||
|
||||
-----------------------------------------------------------
|
||||
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
|
||||
-----------------------------------------------------------
|
||||
|
||||
PREAMBLE
|
||||
The goals of the Open Font License (OFL) are to stimulate worldwide
|
||||
development of collaborative font projects, to support the font creation
|
||||
efforts of academic and linguistic communities, and to provide a free and
|
||||
open framework in which fonts may be shared and improved in partnership
|
||||
with others.
|
||||
|
||||
The OFL allows the licensed fonts to be used, studied, modified and
|
||||
redistributed freely as long as they are not sold by themselves. The
|
||||
fonts, including any derivative works, can be bundled, embedded,
|
||||
redistributed and/or sold with any software provided that any reserved
|
||||
names are not used by derivative works. The fonts and derivatives,
|
||||
however, cannot be released under any other type of license. The
|
||||
requirement for fonts to remain under this license does not apply
|
||||
to any document created using the fonts or their derivatives.
|
||||
|
||||
DEFINITIONS
|
||||
"Font Software" refers to the set of files released by the Copyright
|
||||
Holder(s) under this license and clearly marked as such. This may
|
||||
include source files, build scripts and documentation.
|
||||
|
||||
"Reserved Font Name" refers to any names specified as such after the
|
||||
copyright statement(s).
|
||||
|
||||
"Original Version" refers to the collection of Font Software components as
|
||||
distributed by the Copyright Holder(s).
|
||||
|
||||
"Modified Version" refers to any derivative made by adding to, deleting,
|
||||
or substituting -- in part or in whole -- any of the components of the
|
||||
Original Version, by changing formats or by porting the Font Software to a
|
||||
new environment.
|
||||
|
||||
"Author" refers to any designer, engineer, programmer, technical
|
||||
writer or other person who contributed to the Font Software.
|
||||
|
||||
PERMISSION & CONDITIONS
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of the Font Software, to use, study, copy, merge, embed, modify,
|
||||
redistribute, and sell modified and unmodified copies of the Font
|
||||
Software, subject to the following conditions:
|
||||
|
||||
1) Neither the Font Software nor any of its individual components,
|
||||
in Original or Modified Versions, may be sold by itself.
|
||||
|
||||
2) Original or Modified Versions of the Font Software may be bundled,
|
||||
redistributed and/or sold with any software, provided that each copy
|
||||
contains the above copyright notice and this license. These can be
|
||||
included either as stand-alone text files, human-readable headers or
|
||||
in the appropriate machine-readable metadata fields within text or
|
||||
binary files as long as those fields can be easily viewed by the user.
|
||||
|
||||
3) No Modified Version of the Font Software may use the Reserved Font
|
||||
Name(s) unless explicit written permission is granted by the corresponding
|
||||
Copyright Holder. This restriction only applies to the primary font name as
|
||||
presented to the users.
|
||||
|
||||
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
|
||||
Software shall not be used to promote, endorse or advertise any
|
||||
Modified Version, except to acknowledge the contribution(s) of the
|
||||
Copyright Holder(s) and the Author(s) or with their explicit written
|
||||
permission.
|
||||
|
||||
5) The Font Software, modified or unmodified, in part or in whole,
|
||||
must be distributed entirely under this license, and must not be
|
||||
distributed under any other license. The requirement for fonts to
|
||||
remain under this license does not apply to any document created
|
||||
using the Font Software.
|
||||
|
||||
TERMINATION
|
||||
This license becomes null and void if any of the above conditions are
|
||||
not met.
|
||||
|
||||
DISCLAIMER
|
||||
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
|
||||
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
|
||||
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
|
||||
OTHER DEALINGS IN THE FONT SOFTWARE.
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,208 @@
|
||||
<!doctype html>
|
||||
<html lang="en" data-theme="light">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Strata</title>
|
||||
<link rel="stylesheet" href="/web/tokens.css">
|
||||
<link rel="stylesheet" href="/web/components.css">
|
||||
<link rel="stylesheet" href="/web/app.css">
|
||||
<script>
|
||||
// the theme before the first paint: the saved choice, else the system's
|
||||
try {
|
||||
const t = localStorage.getItem("strata.theme") ||
|
||||
(matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light");
|
||||
document.documentElement.dataset.theme = t;
|
||||
} catch (e) {}
|
||||
</script>
|
||||
</head>
|
||||
<body>
|
||||
<header class="st-header">
|
||||
<span class="st-header__brand">Strata</span>
|
||||
<nav class="st-tabs" role="tablist" aria-label="Views">
|
||||
<button class="st-tab" role="tab" id="tab-btn-chat" aria-controls="view-chat" aria-selected="true" data-tab="chat">
|
||||
<svg class="st-icon st-icon--sm"><use href="/web/sprite.svg#i-chat"/></svg>Chat</button>
|
||||
<button class="st-tab" role="tab" id="tab-btn-monitor" aria-controls="view-monitor" aria-selected="false" data-tab="monitor">
|
||||
<svg class="st-icon st-icon--sm"><use href="/web/sprite.svg#i-activity"/></svg>Monitor</button>
|
||||
<button class="st-tab" role="tab" id="tab-btn-about" aria-controls="view-about" aria-selected="false" data-tab="about">
|
||||
<svg class="st-icon st-icon--sm"><use href="/web/sprite.svg#i-info"/></svg>About</button>
|
||||
</nav>
|
||||
<span class="st-header__spacer"></span>
|
||||
<span class="st-pill" id="pill" data-state="idle" role="status" aria-live="polite">
|
||||
<span class="st-pill__dot"></span><span id="pill-text">Connecting…</span></span>
|
||||
<button class="st-btn st-btn--icon" id="theme-btn" title="Light / dark" aria-label="Switch between light and dark">
|
||||
<svg class="st-icon"><use id="theme-icon" href="/web/sprite.svg#i-moon"/></svg></button>
|
||||
</header>
|
||||
|
||||
<main>
|
||||
<!-- ============================ Chat ============================ -->
|
||||
<section class="view view--chat" id="view-chat" role="tabpanel" aria-labelledby="tab-btn-chat">
|
||||
<div class="chat-scroll" id="chat-scroll">
|
||||
<div class="chat" id="chat">
|
||||
<div class="chat-empty" id="chat-empty">
|
||||
<div class="chat-empty__title">Ask anything</div>
|
||||
<div class="chat-empty__sub" id="chat-empty-sub">The model runs on this PC. Nothing leaves it.</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="composer-wrap">
|
||||
<form class="st-composer" id="composer">
|
||||
<div class="attachments" id="attachments" hidden></div>
|
||||
<textarea id="input" rows="2" placeholder="Ask anything…" aria-label="Message"></textarea>
|
||||
<div class="st-composer__bar">
|
||||
<button type="button" class="st-btn st-btn--icon" id="attach-btn" title="Attach a picture" aria-label="Attach a picture" hidden>
|
||||
<svg class="st-icon"><use href="/web/sprite.svg#i-attach"/></svg></button>
|
||||
<input type="file" id="file" accept="image/*" multiple hidden>
|
||||
<button type="button" class="st-btn st-btn--icon" id="new-btn" title="New chat" aria-label="New chat">
|
||||
<svg class="st-icon"><use href="/web/sprite.svg#i-new-chat"/></svg></button>
|
||||
<button type="button" class="st-btn st-btn--icon" id="export-btn" title="Save this chat as Markdown" aria-label="Save this chat">
|
||||
<svg class="st-icon"><use href="/web/sprite.svg#i-download"/></svg></button>
|
||||
<button type="button" class="st-btn st-btn--icon" id="sampling-btn" title="Sampling and thinking" aria-label="Sampling and thinking">
|
||||
<svg class="st-icon"><use href="/web/sprite.svg#i-settings"/></svg></button>
|
||||
<span class="spacer"></span>
|
||||
<span class="composer-hint" id="composer-hint"></span>
|
||||
<button type="button" class="st-btn st-btn--secondary" id="stop-btn" hidden>
|
||||
<svg class="st-icon st-icon--sm"><use href="/web/sprite.svg#i-stop"/></svg>Stop</button>
|
||||
<button type="submit" class="st-btn st-btn--primary st-btn--send" id="send-btn" aria-label="Send">
|
||||
<svg class="st-icon"><use href="/web/sprite.svg#i-send"/></svg></button>
|
||||
</div>
|
||||
</form>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- ============================ Monitor ============================ -->
|
||||
<section class="view view--monitor" id="view-monitor" role="tabpanel" aria-labelledby="tab-btn-monitor" hidden>
|
||||
<div class="monitor">
|
||||
<div class="st-card state-card">
|
||||
<div class="state-card__head">
|
||||
<span class="card-title">Model state</span>
|
||||
<span class="badges" id="state-badges">
|
||||
<span class="st-badge" data-s="idle">Idle</span>
|
||||
<span class="st-badge st-badge--reading" data-s="reading">Reading</span>
|
||||
<span class="st-badge st-badge--generating" data-s="generating">Generating</span>
|
||||
<span class="st-badge st-badge--queued" data-s="queued">Queued</span>
|
||||
<span class="st-badge st-badge--error" data-s="error">Error</span>
|
||||
</span>
|
||||
</div>
|
||||
<div class="state-card__row"><span id="state-label">Waiting for a request</span><span class="muted" id="state-detail"></span></div>
|
||||
<div class="st-progress" id="state-progress"><div class="st-progress__bar" id="state-bar" style="width:0%"></div></div>
|
||||
</div>
|
||||
|
||||
<div class="metrics" id="metrics">
|
||||
<!-- filled by app.js: Speed, GPU load, VRAM, GPU temp, Power, PCIe, CPU, Disk read -->
|
||||
</div>
|
||||
|
||||
<div class="monitor-row">
|
||||
<div class="st-card ctx-card">
|
||||
<span class="card-title">Context fill</span>
|
||||
<div class="ctx-gauge">
|
||||
<svg class="st-gauge" viewBox="0 0 120 120" aria-hidden="true">
|
||||
<circle class="st-gauge__track" cx="60" cy="60" r="50" fill="none" stroke-width="10" stroke-linecap="round"
|
||||
stroke-dasharray="235.6 314.2" transform="rotate(135 60 60)"/>
|
||||
<circle class="st-gauge__fill" id="ctx-fill" cx="60" cy="60" r="50" fill="none" stroke-width="10"
|
||||
stroke-linecap="round" stroke-dasharray="0 314.2" transform="rotate(135 60 60)"/>
|
||||
</svg>
|
||||
<div class="ctx-gauge__label"><span class="ctx-gauge__pct" id="ctx-pct">0%</span><span class="muted" id="ctx-sub">–</span></div>
|
||||
</div>
|
||||
<div class="bar-row"><span>Experts in VRAM</span><span class="muted" id="slots-text">–</span></div>
|
||||
<div class="st-progress"><div class="st-progress__bar" id="slots-bar" style="width:0%"></div></div>
|
||||
<div class="bar-row"><span>System RAM</span><span class="muted" id="ram-text">–</span></div>
|
||||
<div class="st-progress" id="ram-progress"><div class="st-progress__bar" id="ram-bar" style="width:0%"></div></div>
|
||||
<div class="bar-row"><span>GPU temperature</span><span class="muted" id="temp-text">–</span></div>
|
||||
<div class="st-progress" data-tone="warn"><div class="st-progress__bar" id="temp-bar" style="width:0%"></div></div>
|
||||
</div>
|
||||
<div class="st-card req-card">
|
||||
<span class="card-title">Recent requests</span>
|
||||
<div class="table-wrap">
|
||||
<table class="st-table">
|
||||
<thead><tr><th>Time</th><th>Status</th><th class="num">Prompt</th><th class="num">Reused</th><th class="num">Output</th>
|
||||
<th class="num">Tok/s</th><th class="num">Duration</th></tr></thead>
|
||||
<tbody id="req-body"><tr><td colspan="7" class="muted">No requests yet</td></tr></tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- ============================ About ============================ -->
|
||||
<section class="view view--about" id="view-about" role="tabpanel" aria-labelledby="tab-btn-about" hidden>
|
||||
<div class="about">
|
||||
<div class="st-card">
|
||||
<span class="card-title">Model and engine</span>
|
||||
<dl class="facts" id="facts-engine"></dl>
|
||||
</div>
|
||||
<div class="st-card">
|
||||
<span class="card-title">This PC</span>
|
||||
<dl class="facts" id="facts-hw"></dl>
|
||||
</div>
|
||||
<div class="st-card">
|
||||
<span class="card-title">Connect your tools</span>
|
||||
<p class="muted">Any OpenAI- or Anthropic-compatible client works with these addresses.</p>
|
||||
<dl class="facts" id="facts-api"></dl>
|
||||
</div>
|
||||
<div class="st-card">
|
||||
<span class="card-title">Settings</span>
|
||||
<div class="st-field">
|
||||
<label class="st-label" for="api-key">API key <output>only if the server was started with one</output></label>
|
||||
<input class="st-input" id="api-key" type="password" autocomplete="off" placeholder="Not needed">
|
||||
</div>
|
||||
<div class="toggle-row"><span>Dark theme</span>
|
||||
<button class="st-toggle" id="dark-toggle" role="switch" aria-checked="false" aria-label="Dark theme"></button></div>
|
||||
<p class="muted small">Chats, settings and the key are kept in this browser only.
|
||||
<a href="https://github.com/Niko1221/Strata" target="_blank" rel="noopener noreferrer">Strata on GitHub</a></p>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
</main>
|
||||
|
||||
<!-- ============================ Sampling drawer ============================ -->
|
||||
<aside class="st-drawer" id="drawer" data-open="false" aria-label="Sampling and thinking" aria-hidden="true">
|
||||
<div class="st-drawer__head"><span class="card-title">Sampling</span>
|
||||
<button class="st-btn st-btn--icon" id="drawer-close" aria-label="Close">
|
||||
<svg class="st-icon"><use href="/web/sprite.svg#i-chevron"/></svg></button></div>
|
||||
<div class="st-drawer__body">
|
||||
<div class="st-field">
|
||||
<label class="st-label" for="s-thinking">Thinking <output id="o-thinking"></output></label>
|
||||
<div class="seg" id="s-thinking" role="radiogroup" aria-label="Thinking">
|
||||
<button type="button" role="radio" data-v="none">Off</button><button type="button" role="radio" data-v="low">Low</button>
|
||||
<button type="button" role="radio" data-v="medium">Medium</button><button type="button" role="radio" data-v="high">High</button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="st-field">
|
||||
<label class="st-label" for="s-temp">Temperature <output id="o-temp"></output></label>
|
||||
<input class="st-slider" type="range" id="s-temp" min="0" max="1.5" step="0.05">
|
||||
<span class="muted small">0 = always the most likely word (exact, repeatable)</span>
|
||||
</div>
|
||||
<div class="st-field">
|
||||
<label class="st-label" for="s-topp">Top-p <output id="o-topp"></output></label>
|
||||
<input class="st-slider" type="range" id="s-topp" min="0.05" max="1" step="0.05">
|
||||
</div>
|
||||
<div class="st-field">
|
||||
<label class="st-label" for="s-topk">Top-k <output id="o-topk"></output></label>
|
||||
<input class="st-slider" type="range" id="s-topk" min="1" max="64" step="1">
|
||||
</div>
|
||||
<div class="st-field">
|
||||
<label class="st-label" for="s-max">Max tokens <output>empty = until done</output></label>
|
||||
<input class="st-input" id="s-max" type="number" min="1" step="1" placeholder="Until done">
|
||||
</div>
|
||||
<div class="st-field">
|
||||
<label class="st-label" for="s-seed">Seed <output>empty = random</output></label>
|
||||
<input class="st-input" id="s-seed" type="number" min="1" step="1" placeholder="Random">
|
||||
</div>
|
||||
<div class="toggle-row"><span>Show thinking<br><span class="muted small">expanded while it streams</span></span>
|
||||
<button class="st-toggle" id="s-show" role="switch" aria-checked="true" aria-label="Show thinking"></button></div>
|
||||
<div class="toggle-row" id="esp-row" hidden><span>Experimental speed projection<br><span class="muted small">the
|
||||
engine's control vector; off = the stock model. Switching reads the chat again once</span></span>
|
||||
<button class="st-toggle" id="s-esp" role="switch" aria-checked="true" aria-label="Experimental speed projection"></button></div>
|
||||
<div class="drawer-actions">
|
||||
<button class="st-btn st-btn--secondary" id="s-reset" type="button">Reset</button>
|
||||
<button class="st-btn st-btn--primary" id="s-apply" type="button">Apply</button>
|
||||
</div>
|
||||
</div>
|
||||
</aside>
|
||||
<div class="scrim" id="scrim" hidden></div>
|
||||
<div class="st-toasts" id="toasts" aria-live="polite"></div>
|
||||
<script src="/web/app.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,34 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" style="display:none" xmlns:c2pa="http://c2pa.org/manifest"><metadata><c2pa:manifest>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 truncated
|
||||
<symbol id="i-chat" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M21 11.5C21 16.194 16.971 20 12 20C10.8 20 9.65 19.78 8.6 19.37L4 20.5L5.2 16.8C3.83 15.34 3 13.5 3 11.5C3 6.806 7.029 3 12 3C16.971 3 21 6.806 21 11.5Z" fill="currentColor"></path><path d="M21 11.5C21 16.194 16.971 20 12 20C10.8 20 9.65 19.78 8.6 19.37L4 20.5L5.2 16.8C3.83 15.34 3 13.5 3 11.5C3 6.806 7.029 3 12 3C16.971 3 21 6.806 21 11.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M8 11.5H8.01M12 11.5H12.01M16 11.5H16.01" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-activity" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M2 12C2 7.286 2 4.929 3.464 3.464C4.929 2 7.286 2 12 2C16.714 2 19.071 2 20.536 3.464C22 4.929 22 7.286 22 12C22 16.714 22 19.071 20.536 20.536C19.071 22 16.714 22 12 22C7.286 22 4.929 22 3.464 20.536C2 19.071 2 16.714 2 12Z" fill="currentColor"></path><path d="M2 12C2 7.286 2 4.929 3.464 3.464C4.929 2 7.286 2 12 2C16.714 2 19.071 2 20.536 3.464C22 4.929 22 7.286 22 12C22 16.714 22 19.071 20.536 20.536C19.071 22 16.714 22 12 22C7.286 22 4.929 22 3.464 20.536C2 19.071 2 16.714 2 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M6 12.5H8.5L10.5 8L13.5 16L15.5 11.5H18" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-settings" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M12.22 2H11.78A2 2 0 0 0 9.78 4V4.18A2 2 0 0 1 8.78 5.91L8.35 6.16A2 2 0 0 1 6.35 6.16L6.2 6.08A2 2 0 0 0 3.47 6.81L3.25 7.19A2 2 0 0 0 3.98 9.92L4.13 10.02A2 2 0 0 1 5.13 11.74V12.25A2 2 0 0 1 4.13 13.99L3.98 14.08A2 2 0 0 0 3.25 16.81L3.47 17.19A2 2 0 0 0 6.2 17.92L6.35 17.84A2 2 0 0 1 8.35 17.84L8.78 18.09A2 2 0 0 1 9.78 19.82V20A2 2 0 0 0 11.78 22H12.22A2 2 0 0 0 14.22 20V19.82A2 2 0 0 1 15.22 18.09L15.65 17.84A2 2 0 0 1 17.65 17.84L17.8 17.92A2 2 0 0 0 20.53 17.19L20.75 16.8A2 2 0 0 0 20.02 14.07L19.87 13.99A2 2 0 0 1 18.87 12.25V11.75A2 2 0 0 1 19.87 10.01L20.02 9.92A2 2 0 0 0 20.75 7.19L20.53 6.81A2 2 0 0 0 17.8 6.08L17.65 6.16A2 2 0 0 1 15.65 6.16L15.22 5.91A2 2 0 0 1 14.22 4.18V4A2 2 0 0 0 12.22 2Z" fill="currentColor"></path><path d="M12.22 2H11.78A2 2 0 0 0 9.78 4V4.18A2 2 0 0 1 8.78 5.91L8.35 6.16A2 2 0 0 1 6.35 6.16L6.2 6.08A2 2 0 0 0 3.47 6.81L3.25 7.19A2 2 0 0 0 3.98 9.92L4.13 10.02A2 2 0 0 1 5.13 11.74V12.25A2 2 0 0 1 4.13 13.99L3.98 14.08A2 2 0 0 0 3.25 16.81L3.47 17.19A2 2 0 0 0 6.2 17.92L6.35 17.84A2 2 0 0 1 8.35 17.84L8.78 18.09A2 2 0 0 1 9.78 19.82V20A2 2 0 0 0 11.78 22H12.22A2 2 0 0 0 14.22 20V19.82A2 2 0 0 1 15.22 18.09L15.65 17.84A2 2 0 0 1 17.65 17.84L17.8 17.92A2 2 0 0 0 20.53 17.19L20.75 16.8A2 2 0 0 0 20.02 14.07L19.87 13.99A2 2 0 0 1 18.87 12.25V11.75A2 2 0 0 1 19.87 10.01L20.02 9.92A2 2 0 0 0 20.75 7.19L20.53 6.81A2 2 0 0 0 17.8 6.08L17.65 6.16A2 2 0 0 1 15.65 6.16L15.22 5.91A2 2 0 0 1 14.22 4.18V4A2 2 0 0 0 12.22 2Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M15 12C15 13.6569 13.6569 15 12 15C10.3431 15 9 13.6569 9 12C9 10.3431 10.3431 9 12 9C13.6569 9 15 10.3431 15 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-gpu" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M2 7.5C2 6.12 3.12 5 4.5 5H19.5C20.88 5 22 6.12 22 7.5V15.5C22 16.88 20.88 18 19.5 18H4.5C3.12 18 2 16.88 2 15.5V7.5Z" fill="currentColor"></path><path d="M2 7.5C2 6.12 3.12 5 4.5 5H19.5C20.88 5 22 6.12 22 7.5V15.5C22 16.88 20.88 18 19.5 18H4.5C3.12 18 2 16.88 2 15.5V7.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12.5 11.5C12.5 13.433 10.933 15 9 15C7.067 15 5.5 13.433 5.5 11.5C5.5 9.567 7.067 8 9 8C10.933 8 12.5 9.567 12.5 11.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M16 9V14M19 9V14" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M6 18V20.5M10 18V20.5M14 18V20.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-cpu" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M6 9C6 7.343 7.343 6 9 6H15C16.657 6 18 7.343 18 9V15C18 16.657 16.657 18 15 18H9C7.343 18 6 16.657 6 15V9Z" fill="currentColor"></path><path d="M6 9C6 7.343 7.343 6 9 6H15C16.657 6 18 7.343 18 9V15C18 16.657 16.657 18 15 18H9C7.343 18 6 16.657 6 15V9Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M10 11C10 10.448 10.448 10 11 10H13C13.552 10 14 10.448 14 11V13C14 13.552 13.552 14 13 14H11C10.448 14 10 13.552 10 13V11Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M9.5 2.5V6M14.5 2.5V6M9.5 18V21.5M14.5 18V21.5M2.5 9.5H6M2.5 14.5H6M18 9.5H21.5M18 14.5H21.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-memory" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M2 8C2 6.895 2.895 6 4 6H20C21.105 6 22 6.895 22 8V15H2V8Z" fill="currentColor"></path><path d="M2 8C2 6.895 2.895 6 4 6H20C21.105 6 22 6.895 22 8V15H2V8Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M6 9.5V11.5M10 9.5V11.5M14 9.5V11.5M18 9.5V11.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M4 15V18M8 15V18M12 15V18M16 15V18M20 15V18" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-disk" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M2 9C2 7.343 3.343 6 5 6H19C20.657 6 22 7.343 22 9V15C22 16.657 20.657 18 19 18H5C3.343 18 2 16.657 2 15V9Z" fill="currentColor"></path><path d="M2 9C2 7.343 3.343 6 5 6H19C20.657 6 22 7.343 22 9V15C22 16.657 20.657 18 19 18H5C3.343 18 2 16.657 2 15V9Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M6 12H12.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M17.5 12H17.51" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-thermometer" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M14 14.76V5C14 3.895 13.105 3 12 3C10.895 3 10 3.895 10 5V14.76C8.8 15.45 8 16.73 8 18.2C8 20.4 9.8 22 12 22C14.2 22 16 20.4 16 18.2C16 16.73 15.2 15.45 14 14.76Z" fill="currentColor"></path><path d="M14 14.76V5C14 3.895 13.105 3 12 3C10.895 3 10 3.895 10 5V14.76C8.8 15.45 8 16.73 8 18.2C8 20.4 9.8 22 12 22C14.2 22 16 20.4 16 18.2C16 16.73 15.2 15.45 14 14.76Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12 17.5V9" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-bolt" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M13 2L4 14H11L10 22L20 9.5H13L13 2Z" fill="currentColor"></path><path d="M13 2L4 14H11L10 22L20 9.5H13L13 2Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-link" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M8.46 20.06L14.26 14.26A3.2 3.2 0 0 0 9.74 9.74L3.94 15.54A3.2 3.2 0 0 0 8.46 20.06Z" fill="currentColor"></path><path d="M10 13C10.43 13.57 10.98 14.05 11.61 14.39C12.24 14.74 12.93 14.94 13.65 14.99C14.36 15.04 15.08 14.94 15.75 14.69C16.42 14.44 17.03 14.05 17.54 13.54L20.54 10.54C21.45 9.6 21.95 8.33 21.94 7.02C21.93 5.71 21.41 4.46 20.48 3.53C19.55 2.6 18.3 2.08 16.99 2.07C15.68 2.06 14.41 2.56 13.47 3.47L11.75 5.18" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M14 11C13.57 10.43 13.02 9.95 12.39 9.61C11.76 9.26 11.07 9.06 10.35 9.01C9.64 8.96 8.92 9.06 8.25 9.31C7.58 9.56 6.97 9.95 6.46 10.46L3.46 13.46C2.55 14.4 2.05 15.67 2.06 16.98C2.07 18.29 2.59 19.54 3.52 20.47C4.45 21.4 5.7 21.92 7.01 21.93C8.32 21.94 9.59 21.44 10.53 20.53L12.24 18.82" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-clock" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z" fill="currentColor"></path><path d="M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12 7V12L15 14" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-gauge" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M2 15C2 9.477 6.477 5 12 5C17.523 5 22 9.477 22 15C22 16.5 21.7 17.8 21.1 19H2.9C2.3 17.8 2 16.5 2 15Z" fill="currentColor"></path><path d="M2 15C2 9.477 6.477 5 12 5C17.523 5 22 9.477 22 15C22 16.5 21.7 17.8 21.1 19H2.9C2.3 17.8 2 16.5 2 15Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12 15L16 10.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M13 15C13 15.552 12.552 16 12 16C11.448 16 11 15.552 11 15C11 14.448 11.448 14 12 14C12.552 14 13 14.448 13 15Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-layers" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M12 3L22 8L12 13L2 8L12 3Z" fill="currentColor"></path><path d="M12 3L22 8L12 13L2 8L12 3Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M2 12L12 17L22 12" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M2 16L12 21L22 16" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-experts" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M3 5.5C3 4.119 4.119 3 5.5 3H6.5C7.881 3 9 4.119 9 5.5V6.5C9 7.881 7.881 9 6.5 9H5.5C4.119 9 3 7.881 3 6.5V5.5Z" fill="currentColor"></path><path opacity="0.12" d="M15 17.5C15 16.119 16.119 15 17.5 15H18.5C19.881 15 21 16.119 21 17.5V18.5C21 19.881 19.881 21 18.5 21H17.5C16.119 21 15 19.881 15 18.5V17.5Z" fill="currentColor"></path><path d="M3 5.5C3 4.119 4.119 3 5.5 3H6.5C7.881 3 9 4.119 9 5.5V6.5C9 7.881 7.881 9 6.5 9H5.5C4.119 9 3 7.881 3 6.5V5.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M15 5.5C15 4.119 16.119 3 17.5 3H18.5C19.881 3 21 4.119 21 5.5V6.5C21 7.881 19.881 9 18.5 9H17.5C16.119 9 15 7.881 15 6.5V5.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M3 17.5C3 16.119 4.119 15 5.5 15H6.5C7.881 15 9 16.119 9 17.5V18.5C9 19.881 7.881 21 6.5 21H5.5C4.119 21 3 19.881 3 18.5V17.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M15 17.5C15 16.119 16.119 15 17.5 15H18.5C19.881 15 21 16.119 21 17.5V18.5C21 19.881 19.881 21 18.5 21H17.5C16.119 21 15 19.881 15 18.5V17.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-send" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M21 3L2 10L10 13.5L13.5 21L21 3Z" fill="currentColor"></path><path d="M21 3L2 10L10 13.5L13.5 21L21 3Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M10 13.5L21 3" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-stop" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M5 8C5 6.343 6.343 5 8 5H16C17.657 5 19 6.343 19 8V16C19 17.657 17.657 19 16 19H8C6.343 19 5 17.657 5 16V8Z" fill="currentColor"></path><path d="M5 8C5 6.343 6.343 5 8 5H16C17.657 5 19 6.343 19 8V16C19 17.657 17.657 19 16 19H8C6.343 19 5 17.657 5 16V8Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-attach" viewBox="0 0 24 24" fill="none"><path d="M21.44 11.05L12.25 20.24A6 6 0 0 1 3.76 11.75L12.33 3.18A4 4 0 1 1 18 8.84L9.41 17.41A2 2 0 0 1 6.58 14.58L15.07 6.1" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-image" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M3 7C3 4.791 4.791 3 7 3H17C19.209 3 21 4.791 21 7V17C21 19.209 19.209 21 17 21H7C4.791 21 3 19.209 3 17V7Z" fill="currentColor"></path><path d="M3 7C3 4.791 4.791 3 7 3H17C19.209 3 21 4.791 21 7V17C21 19.209 19.209 21 17 21H7C4.791 21 3 19.209 3 17V7Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M10 8.5C10 9.328 9.328 10 8.5 10C7.672 10 7 9.328 7 8.5C7 7.672 7.672 7 8.5 7C9.328 7 10 7.672 10 8.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M3.5 17.5L8 13L11 16L15 12L20.5 17.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-copy" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M8 10C8 8.895 8.895 8 10 8H18C19.105 8 20 8.895 20 10V18C20 19.105 19.105 20 18 20H10C8.895 20 8 19.105 8 18V10Z" fill="currentColor"></path><path d="M8 10C8 8.895 8.895 8 10 8H18C19.105 8 20 8.895 20 10V18C20 19.105 19.105 20 18 20H10C8.895 20 8 19.105 8 18V10Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M16 8V6C16 4.895 15.105 4 14 4H6C4.895 4 4 4.895 4 6V14C4 15.105 4.895 16 6 16H8" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-check" viewBox="0 0 24 24" fill="none"><path d="M4.5 12.5L9.5 17.5L19.5 6.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-trash" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M5 6L6 19C6.08 20.1 7 21 8.1 21H15.9C17 21 17.92 20.1 18 19L19 6H5Z" fill="currentColor"></path><path d="M5 6L6 19C6.08 20.1 7 21 8.1 21H15.9C17 21 17.92 20.1 18 19L19 6" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M3 6H21" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M9 6V4.5C9 3.672 9.672 3 10.5 3H13.5C14.328 3 15 3.672 15 4.5V6" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M10 10.5V16.5M14 10.5V16.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-new-chat" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M21 11.5C21 16.194 16.971 20 12 20C10.8 20 9.65 19.78 8.6 19.37L4 20.5L5.2 16.8C3.83 15.34 3 13.5 3 11.5C3 6.806 7.029 3 12 3C16.971 3 21 6.806 21 11.5Z" fill="currentColor"></path><path d="M21 11.5C21 16.194 16.971 20 12 20C10.8 20 9.65 19.78 8.6 19.37L4 20.5L5.2 16.8C3.83 15.34 3 13.5 3 11.5C3 6.806 7.029 3 12 3C16.971 3 21 6.806 21 11.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12 8.5V14.5M9 11.5H15" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-chevron" viewBox="0 0 24 24" fill="none"><path d="M6 9L12 15L18 9" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-thinking" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M12 2.5C8.41 2.5 5.5 5.41 5.5 9C5.5 11.3 6.7 13.3 8.5 14.5V16.5C8.5 17.05 8.95 17.5 9.5 17.5H14.5C15.05 17.5 15.5 17.05 15.5 16.5V14.5C17.3 13.3 18.5 11.3 18.5 9C18.5 5.41 15.59 2.5 12 2.5Z" fill="currentColor"></path><path d="M12 2.5C8.41 2.5 5.5 5.41 5.5 9C5.5 11.3 6.7 13.3 8.5 14.5V16.5C8.5 17.05 8.95 17.5 9.5 17.5H14.5C15.05 17.5 15.5 17.05 15.5 16.5V14.5C17.3 13.3 18.5 11.3 18.5 9C18.5 5.41 15.59 2.5 12 2.5Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M9.5 20.5H14.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-tool" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M14.7 6.3A1 1 0 0 0 14.7 7.7L16.3 9.3A1 1 0 0 0 17.7 9.3L21.47 5.53A6 6 0 0 1 13.53 13.47L6.62 20.38A2.12 2.12 0 0 1 3.62 17.38L10.53 10.47A6 6 0 0 1 18.47 2.53L14.71 6.29Z" fill="currentColor"></path><path d="M14.7 6.3A1 1 0 0 0 14.7 7.7L16.3 9.3A1 1 0 0 0 17.7 9.3L21.47 5.53A6 6 0 0 1 13.53 13.47L6.62 20.38A2.12 2.12 0 0 1 3.62 17.38L10.53 10.47A6 6 0 0 1 18.47 2.53L14.71 6.29Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-download" viewBox="0 0 24 24" fill="none"><path d="M4 15V17C4 18.657 5.343 20 7 20H17C18.657 20 20 18.657 20 17V15" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12 4V14M12 14L8 10M12 14L16 10" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-warning" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M10.24 3.99L2.4 17.5C1.62 18.83 2.58 20.5 4.12 20.5H19.88C21.42 20.5 22.38 18.83 21.6 17.5L13.76 3.99C12.98 2.66 11.02 2.66 10.24 3.99Z" fill="currentColor"></path><path d="M10.24 3.99L2.4 17.5C1.62 18.83 2.58 20.5 4.12 20.5H19.88C21.42 20.5 22.38 18.83 21.6 17.5L13.76 3.99C12.98 2.66 11.02 2.66 10.24 3.99Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12 9V13M12 16.5H12.01" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-error" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z" fill="currentColor"></path><path d="M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M15 9L9 15M9 9L15 15" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-info" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z" fill="currentColor"></path><path d="M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12 11V16.5M12 7.5H12.01" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-refresh" viewBox="0 0 24 24" fill="none"><path d="M21 12A9 9 0 1 1 18.36 5.64L21 8" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M21 3V8H16" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-sun" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M16 12C16 14.209 14.209 16 12 16C9.791 16 8 14.209 8 12C8 9.791 9.791 8 12 8C14.209 8 16 9.791 16 12Z" fill="currentColor"></path><path d="M16 12C16 14.209 14.209 16 12 16C9.791 16 8 14.209 8 12C8 9.791 9.791 8 12 8C14.209 8 16 9.791 16 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path><path d="M12 2V4M12 20V22M4.93 4.93L6.34 6.34M17.66 17.66L19.07 19.07M2 12H4M20 12H22M4.93 19.07L6.34 17.66M17.66 6.34L19.07 4.93" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
<symbol id="i-moon" viewBox="0 0 24 24" fill="none"><path opacity="0.12" d="M21 12.79A9 9 0 1 1 11.21 3A7 7 0 0 0 21 12.79Z" fill="currentColor"></path><path d="M21 12.79A9 9 0 1 1 11.21 3A7 7 0 0 0 21 12.79Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></symbol>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 28 KiB |
@@ -0,0 +1,87 @@
|
||||
/* Strata UI — tokens. Derived from the Gainsty design system.
|
||||
Light is default; dark via <html data-theme="dark">.
|
||||
Values marked (derived) are not in the Gainsty source and were added for the app. */
|
||||
|
||||
/* Outfit (SIL Open Font License 1.1, serve/web/fonts/OFL.txt): one variable font, weights 100-900 */
|
||||
@font-face{font-family:"Outfit";src:url("/fonts/outfit-latin-wght.woff2") format("woff2-variations");font-weight:100 900;font-display:swap;unicode-range:U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD}
|
||||
@font-face{font-family:"Outfit";src:url("/fonts/outfit-latin-ext-wght.woff2") format("woff2-variations");font-weight:100 900;font-display:swap;unicode-range:U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF}
|
||||
|
||||
:root{
|
||||
/* type */
|
||||
--st-font:"Outfit",system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;
|
||||
--st-font-mono:ui-monospace,"SF Mono","Cascadia Code",Consolas,"Liberation Mono",monospace; /* (derived) */
|
||||
--st-fs-xs:12px; --st-fs-sm:13px; --st-fs-md:14px; --st-fs-base:16px;
|
||||
--st-fs-lg:18px; --st-fs-xl:24px; --st-fs-stat:32px; --st-fs-display:40px;
|
||||
--st-fw-regular:400; --st-fw-medium:500; --st-fw-bold:700; --st-fw-black:900;
|
||||
--st-lh-tight:1.1; --st-lh-body:1.55;
|
||||
|
||||
/* spacing (4pt) */
|
||||
--st-s-1:4px; --st-s-2:8px; --st-s-3:12px; --st-s-4:16px; --st-s-5:20px;
|
||||
--st-s-6:24px; --st-s-8:32px; --st-s-10:40px; --st-s-12:48px; --st-s-16:64px;
|
||||
|
||||
/* radius */
|
||||
--st-r-sm:8px; --st-r-md:14px; --st-r-lg:20px; --st-r-xl:24px; --st-r-pill:9999px;
|
||||
|
||||
/* motion (derived) */
|
||||
--st-ease:cubic-bezier(.2,.7,.2,1); --st-dur:160ms;
|
||||
|
||||
/* color — light */
|
||||
--st-bg:#f9fafb;
|
||||
--st-surface:#ffffff;
|
||||
--st-surface-2:#f7f7f7;
|
||||
--st-line:#dee5ee;
|
||||
--st-line-soft:#eeeeee;
|
||||
--st-ink:#221e1f;
|
||||
--st-ink-soft:#303030;
|
||||
--st-ink-muted:#6f6f6f; /* Gainsty #7a7a7a darkened slightly for 4.5:1 on white */
|
||||
--st-icon:#2F384C; /* Anron default */
|
||||
|
||||
--st-accent:#10b981;
|
||||
--st-accent-hover:#0c8a60;
|
||||
--st-accent-ink:#ffffff;
|
||||
--st-accent-tint:#ecfdf5;
|
||||
--st-accent-text:#0c8a60; /* accent used as text on light */
|
||||
--st-focus:#405de6;
|
||||
|
||||
--st-info:#0f97ff; --st-info-tint:#e8f4ff; --st-info-text:#0668c2;
|
||||
--st-warn:#e39b0b; --st-warn-tint:#fff6e0; --st-warn-text:#8a5a00; /* (derived) */
|
||||
--st-danger:#e0283f; --st-danger-tint:#fdecee; --st-danger-text:#b01a2e; /* (derived) */
|
||||
|
||||
--st-code-bg:#1b1f23; --st-code-ink:#e6e9ec; /* code blocks stay dark in both themes (derived) */
|
||||
|
||||
--st-sh-card:0 18px 7px rgba(0,0,0,.01),0 10px 6px rgba(0,0,0,.02),0 4px 4px rgba(0,0,0,.03),0 1px 2px rgba(0,0,0,.04);
|
||||
--st-sh-bar:0 54px 21px rgba(0,0,0,.01),0 30px 18px rgba(0,0,0,.03),0 13px 13px rgba(0,0,0,.05),0 3px 7px rgba(0,0,0,.06);
|
||||
--st-sh-pop:0 10px 40px rgba(15,23,42,.08),0 1px 3px rgba(15,23,42,.06);
|
||||
color-scheme:light;
|
||||
}
|
||||
|
||||
/* color — dark (all derived) */
|
||||
[data-theme="dark"]{
|
||||
--st-bg:#0e1113;
|
||||
--st-surface:#161a1d;
|
||||
--st-surface-2:#1d2226;
|
||||
--st-line:#2a3036;
|
||||
--st-line-soft:#22272c;
|
||||
--st-ink:#eef1f3;
|
||||
--st-ink-soft:#c7cdd3;
|
||||
--st-ink-muted:#8e979f;
|
||||
--st-icon:#c7cdd3;
|
||||
|
||||
--st-accent:#34d399;
|
||||
--st-accent-hover:#4ade80;
|
||||
--st-accent-ink:#052e20;
|
||||
--st-accent-tint:rgba(52,211,153,.12);
|
||||
--st-accent-text:#4ade80;
|
||||
--st-focus:#7b93ff;
|
||||
|
||||
--st-info:#3aa9ff; --st-info-tint:rgba(58,169,255,.12); --st-info-text:#7cc4ff;
|
||||
--st-warn:#f5b53d; --st-warn-tint:rgba(245,181,61,.12); --st-warn-text:#f8c96a;
|
||||
--st-danger:#ff5a6e; --st-danger-tint:rgba(255,90,110,.12);--st-danger-text:#ff8a98;
|
||||
|
||||
--st-code-bg:#0a0c0e; --st-code-ink:#e6e9ec;
|
||||
|
||||
--st-sh-card:0 1px 2px rgba(0,0,0,.4);
|
||||
--st-sh-bar:0 12px 32px rgba(0,0,0,.45),0 2px 6px rgba(0,0,0,.35);
|
||||
--st-sh-pop:0 16px 48px rgba(0,0,0,.55),0 1px 3px rgba(0,0,0,.4);
|
||||
color-scheme:dark;
|
||||
}
|
||||
@@ -3,15 +3,15 @@
|
||||
|
||||
START-HERE.bat (Windows) / ./setup.sh (Linux) - they install Python if needed and run this file
|
||||
|
||||
The first time it asks three questions - which model, how much context, and whether the model should also read
|
||||
images - then installs everything and starts the model on http://127.0.0.1:8080 (OpenAI- and Anthropic-compatible
|
||||
The first time it asks four questions - which model (the original Qwen3.8-Flash-Next or the Swift 1.5 fine-tune),
|
||||
which size, how much context, and whether the model should also read images - then installs everything and starts the model on http://127.0.0.1:8080 (OpenAI- and Anthropic-compatible
|
||||
API; a small page there shows that it runs). Every later start skips straight to running the model: nothing that
|
||||
is already downloaded, installed or prepared is done again.
|
||||
|
||||
What the first run does (each step is skipped when it is already done):
|
||||
|
||||
1. checks your PC: NVIDIA GPU and driver, RAM, CPU, free disk space
|
||||
2. asks the three questions
|
||||
2. asks the questions
|
||||
3. installs the Python packages it needs into .venv (numpy, jinja2, ..., and NVIDIA's CUDA libraries)
|
||||
4. gets the Strata engine: a ready-made build for RTX 30/40/50 cards (no compiler needed); if none fits your PC,
|
||||
it installs the build tools (asks first) and compiles the engine for your GPU
|
||||
@@ -19,8 +19,10 @@ What the first run does (each step is skipped when it is already done):
|
||||
6. prepares the model for Strata and fetches the MTP draft layer (~5 GB, from the original Qwen checkpoint)
|
||||
7. writes run-<model>.bat / run-<model>.sh and starts the model
|
||||
|
||||
Options: --model Q2_0|IQ2_XS|IQ3_XXS, --context 32768, --vision yes|no|gpu|cpu, --port 8080, --yes (recommended
|
||||
Options: --family qwen|swift, --model Q2_0|IQ2_XS|IQ3_XXS|IQ3_S, --context 32768, --vision yes|no|gpu|cpu, --port 8080, --yes (recommended
|
||||
answers, no questions), --setup (install another model / change settings instead of starting), --no-start,
|
||||
--host 0.0.0.0 --api-key KEY (reach it from other devices on your network), --experimental-speed-projection on|off
|
||||
(EXPERIMENTAL, off by default),
|
||||
--models-dir DIR, --gguf-dir DIR (use GGUF files you already have), --build (compile instead of the ready-made
|
||||
engine), --check (only check this PC).
|
||||
"""
|
||||
@@ -54,20 +56,43 @@ PREBUILT_ASSET = "strata-windows-x64.zip" if WIN else "strata-linux-x64.zip"
|
||||
# the CUDA libraries the ready-made engine loads (the same CUDA 13.0 it is built with), from NVIDIA's pip packages
|
||||
CUDA_WHEELS = ["nvidia-cublas==13.0.2.14", "nvidia-cuda-runtime==13.0.96"]
|
||||
MIN_DRIVER = 580 # CUDA 13.0
|
||||
PY_PACKAGES = ["numpy", "jinja2", "regex", "pyyaml", "tqdm", "requests", "cmake", "ninja"]
|
||||
MIN_ENGINE = (0, 1, 9) # the head loaded before the expert cache is sized (no 128K stalls), v0.1.9
|
||||
PY_PACKAGES = ["numpy", "jinja2", "regex", "pyyaml", "tqdm", "requests", "cmake", "ninja", "pillow", "psutil"]
|
||||
|
||||
MODELS = {
|
||||
"Q2_0": {"about": "2-bit, the fastest", "download_gb": 66.4, "ram_gb": 48, "arena_gb": 34.0},
|
||||
"IQ2_XS": {"about": "2-bit i-quant, a little better quality, close in speed", "download_gb": 68.0, "ram_gb": 48,
|
||||
"arena_gb": 35.5},
|
||||
"IQ3_XXS": {"about": "3-bit i-quant, the best quality, slower (more CPU work per token)", "download_gb": 75.8,
|
||||
"IQ3_XXS": {"about": "3-bit i-quant, better quality, slower (more CPU work per token)", "download_gb": 75.8,
|
||||
"ram_gb": 60, "arena_gb": 42.9},
|
||||
# the original model only (Swift 1.5 has no IQ3_S): matches the full BF16 model on the published benchmarks
|
||||
"IQ3_S": {"about": "3.5-bit i-quant, the best quality (matches the full model), the slowest; needs a 64 GB PC "
|
||||
"with little else running", "download_gb": 83.6, "ram_gb": 62, "arena_gb": 50.3,
|
||||
"families": ("qwen",)},
|
||||
}
|
||||
CONTEXTS = [8192, 32768, 65536, 131072, 262144]
|
||||
# The model families: the same architecture, weights in the same three GSQ-RCO sizes, different files.
|
||||
FAMILIES = {
|
||||
"qwen": {"title": "Qwen3.8-Flash-Next", "by": "Qwen; GSQ-RCO quants by ISTA-DASLab",
|
||||
"about": "the original model",
|
||||
"hf": "https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF/resolve/main/{q}/",
|
||||
"file": "Qwen3.8-Flash-Next-GSQ-RCO-{q}-0000{i}-of-00002.gguf", "tag": "",
|
||||
"mmproj_hf": "https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF/resolve/main/",
|
||||
"mmproj": "mmproj-Qwen3.8-Flash-Next-BF16.gguf", "name": "qwen3.8-flash-next"},
|
||||
"swift": {"title": "Swift 1.5", "by": "UkisAI's fine-tune of Qwen3.8-Flash-Next",
|
||||
"about": "thinks much shorter (-63% thinking tokens, 1.8x sooner answers by its authors' numbers)",
|
||||
"hf": "https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF/resolve/main/",
|
||||
"file": "Swift-Qwen3.8-Flash-Next-GSQ-RCO-{q}-0000{i}-of-00002.gguf", "tag": "swift-",
|
||||
"mmproj_hf": "https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF/resolve/main/",
|
||||
"mmproj": "mmproj-Swift-Qwen3.8-Flash-Next-BF16.gguf", "name": "swift-1.5",
|
||||
"license": "Swift Open License 1.0: https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF"},
|
||||
}
|
||||
MMPROJ = "mmproj-Qwen3.8-Flash-Next-BF16.gguf"
|
||||
# the image encoder on the GPU: ~0.9 GB of weights + ~0.3 GB of work buffers at 1024 image tokens, kept free of
|
||||
# expert slots (the engine's default reserve is 700 MiB)
|
||||
VISION = {"gpu": {"max_tokens": 1024, "reserve_mib": 2100},
|
||||
# EXPERIMENTAL, off by default (setup asks): a control vector shipped with the repository, see its README
|
||||
ESP_VECTOR = ROOT / "data" / "experimental-speed-projection" / "Qwen3.8-Flash-Next-experimental-speed-projection.gguf"
|
||||
# the image encoder on the GPU (~1.2 GB at 1024 image tokens) warms up before the engine starts, so the engine
|
||||
# sizes its expert slots around it and the default reserve (700 MiB) is enough; engines before 0.1.2 need more
|
||||
VISION = {"gpu": {"max_tokens": 1024, "reserve_mib": 700},
|
||||
"cpu": {"max_tokens": 300, "reserve_mib": 700}}
|
||||
EXE = "strata.exe" if WIN else "strata"
|
||||
VEXE = "strata-vision.exe" if WIN else "strata-vision"
|
||||
@@ -384,8 +409,13 @@ def get_prebuilt(url_base, gpu, vision) -> Path | None:
|
||||
eng = ROOT / "engine"
|
||||
info = eng / "BUILD.json"
|
||||
if info.exists() and (eng / EXE).exists():
|
||||
ok("ready-made engine already installed")
|
||||
return eng
|
||||
meta = json.loads(info.read_text())
|
||||
ver = tuple(int(x) for x in str(meta.get("version", "0")).split(".")[:3] if x.isdigit())
|
||||
if meta.get("source") == "local" or ver >= MIN_ENGINE:
|
||||
ok("ready-made engine already installed")
|
||||
return eng
|
||||
say(f" Updating the ready-made engine ({meta.get('version')} -> {'.'.join(map(str, MIN_ENGINE))} or newer) ...")
|
||||
info.unlink()
|
||||
if not url_base:
|
||||
return None
|
||||
z = ROOT / "engine" / PREBUILT_ASSET
|
||||
@@ -404,6 +434,11 @@ def get_prebuilt(url_base, gpu, vision) -> Path | None:
|
||||
with zipfile.ZipFile(z) as f:
|
||||
f.extractall(tmp)
|
||||
meta = json.loads((tmp / "BUILD.json").read_text())
|
||||
if tuple(int(x) for x in str(meta.get("version", "0")).split(".")[:3] if x.isdigit()) < MIN_ENGINE:
|
||||
warn(f"the ready-made engine at {base} is version {meta.get('version')}; this setup needs "
|
||||
f"{'.'.join(map(str, MIN_ENGINE))}: compiling instead")
|
||||
shutil.rmtree(tmp, ignore_errors=True)
|
||||
return None
|
||||
archs = [int(a) for a in meta.get("archs", [])]
|
||||
arch = int(gpu["arch"])
|
||||
if arch not in archs and not (meta.get("ptx") and arch > max(archs)):
|
||||
@@ -429,6 +464,42 @@ def get_prebuilt(url_base, gpu, vision) -> Path | None:
|
||||
return eng
|
||||
|
||||
|
||||
def update_installed_engine(url_base) -> None:
|
||||
"""An installed ready-made engine older than MIN_ENGINE is replaced before the model starts, so a plain
|
||||
START-HERE.bat on an existing install picks up a new release. If that cannot happen (no internet, the model
|
||||
still running, no ready-made engine for this GPU) the installed engine is kept and starts as before."""
|
||||
eng = ROOT / "engine"
|
||||
info = eng / "BUILD.json"
|
||||
if not info.exists() or not (eng / EXE).exists():
|
||||
return
|
||||
meta_text = info.read_text()
|
||||
meta = json.loads(meta_text)
|
||||
ver = tuple(int(x) for x in str(meta.get("version", "0")).split(".")[:3] if x.isdigit())
|
||||
if meta.get("source") == "local" or ver >= MIN_ENGINE:
|
||||
return
|
||||
try: # a running engine cannot be replaced (Windows keeps it locked)
|
||||
for x in (EXE, VEXE):
|
||||
if (eng / x).exists():
|
||||
with open(eng / x, "r+b"):
|
||||
pass
|
||||
except OSError:
|
||||
warn(f"engine {meta.get('version')} is in use: close the model window and run this again to update it")
|
||||
return
|
||||
gpu = gpu_info()
|
||||
new = None
|
||||
if gpu is not None:
|
||||
try:
|
||||
new = get_prebuilt(url_base, gpu, "gpu")
|
||||
except Exception as e: # a failed download must not stop the model from starting
|
||||
warn(f"updating the engine failed ({e})")
|
||||
if new is None:
|
||||
if not info.exists():
|
||||
info.write_text(meta_text) # get_prebuilt drops it before downloading: put it back
|
||||
warn(f"could not update the engine: starting the installed {meta.get('version')}")
|
||||
return
|
||||
pip_install(CUDA_WHEELS, "NVIDIA CUDA libraries (cuBLAS, CUDA runtime; ~0.4 GB)")
|
||||
|
||||
|
||||
def install_build_tools(gpu, yes):
|
||||
"""The compiler and the CUDA toolkit, installed for the user (asks once). Returns (nvcc, vcvars)."""
|
||||
nvcc, cuda_v = find_nvcc()
|
||||
@@ -545,7 +616,7 @@ def installed_configs():
|
||||
|
||||
|
||||
def start(cfg_path: Path, port: int | None, open_browser=True) -> int:
|
||||
cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
|
||||
cfg = json.loads(cfg_path.read_text(encoding="utf-8-sig"))
|
||||
missing = [p for p in [cfg["exe"], *[a for a in cfg["args"] if a.endswith(".gguf")]] if not Path(p).exists()]
|
||||
if missing:
|
||||
fail(f"{cfg_path.name} refers to missing files: {missing[0]}", "run it again with --setup to repair")
|
||||
@@ -577,11 +648,21 @@ def write_run_script(model, cfg_path, port):
|
||||
# ------------------------------------------------------------------------------------------------ main
|
||||
def main() -> int:
|
||||
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
ap.add_argument("--family", choices=list(FAMILIES), help="qwen = Qwen3.8-Flash-Next, swift = Swift 1.5")
|
||||
ap.add_argument("--model", choices=list(MODELS))
|
||||
ap.add_argument("--context", type=int)
|
||||
ap.add_argument("--kv", choices=["int8", "q4_0"],
|
||||
help="KV cache precision above 8K context: int8 (default) or q4_0 (half the memory, a little less "
|
||||
"precise)")
|
||||
ap.add_argument("--vision", choices=["yes", "no", "none", "gpu", "cpu"],
|
||||
help="let the model read images (yes = the encoder on the GPU)")
|
||||
ap.add_argument("--experimental-speed-projection", metavar="on|off|GGUF",
|
||||
help="EXPERIMENTAL, off by default: the control vector in data/experimental-speed-projection "
|
||||
"(or another GGUF) as a projection on layers 4-44; see docs/DETAILS.md")
|
||||
ap.add_argument("--port", type=int, default=8080)
|
||||
ap.add_argument("--host", help="where the server listens: 127.0.0.1 = this PC only (default), 0.0.0.0 = also other "
|
||||
"devices on your network (issue #26; set --api-key too)")
|
||||
ap.add_argument("--api-key", help="require this key from clients (recommended with --host 0.0.0.0)")
|
||||
ap.add_argument("--models-dir", default=str(ROOT / "models"), help="where the GGUF files go (~70 GB)")
|
||||
ap.add_argument("--gguf-dir", help="use GGUF files you already have (a folder with the two shards)")
|
||||
ap.add_argument("--yes", action="store_true", help="accept the recommended answers")
|
||||
@@ -598,12 +679,14 @@ def main() -> int:
|
||||
|
||||
# ---- 0. already installed: just start it
|
||||
have = installed_configs()
|
||||
if have and not (a.setup or a.model or a.check or a.no_start):
|
||||
if have and not (a.setup or a.model or a.family or a.check or a.no_start):
|
||||
if not a.build:
|
||||
update_installed_engine(a.prebuilt)
|
||||
if len(have) == 1:
|
||||
return start(have[0], None)
|
||||
say()
|
||||
for i, c in enumerate(have, 1):
|
||||
say(f" {i}) {c.stem[len('strata-'):].upper()}")
|
||||
say(f" {i}) {json.loads(c.read_text(encoding='utf-8-sig')).get('model_name', c.stem)}")
|
||||
say(f" {len(have) + 1}) install another model / change settings")
|
||||
pick = int(ask("Which one?", [str(i) for i in range(1, len(have) + 2)], "1", a.yes))
|
||||
if pick <= len(have):
|
||||
@@ -626,7 +709,14 @@ def main() -> int:
|
||||
warn("less than 12 GB of VRAM: Strata will run, but most experts stay on the CPU and it will be slow")
|
||||
ram = ram_gb()
|
||||
cpu, avx2, avx512 = cpu_info()
|
||||
ok(f"RAM: {ram:.0f} GB")
|
||||
need = min(d["ram_gb"] for d in MODELS.values())
|
||||
if ram < need - 4 and not a.check:
|
||||
# every model keeps ALL its experts in RAM (34+ GB); VRAM only holds a copy of the most-used ones, so a
|
||||
# bigger GPU does not lower this
|
||||
fail(f"RAM: {ram:.0f} GB - the smallest model (Q2_0 / IQ2_XS) needs about {need} GB",
|
||||
"Strata keeps all of the model's experts in RAM (34-50 GB, whatever the GPU) and the GPU holds a copy "
|
||||
"of the most-used ones: it needs 48 GB of RAM or more")
|
||||
ok(f"RAM: {ram:.0f} GB" if ram >= need - 4 else f"RAM: {ram:.0f} GB (less than the {need} GB the smallest model needs)")
|
||||
ok(f"CPU: {cpu} ({'AVX-512' if avx512 else 'AVX2' if avx2 else 'no AVX2'})")
|
||||
if not avx2:
|
||||
fail("this CPU has no AVX2; Strata needs at least AVX2")
|
||||
@@ -640,17 +730,33 @@ def main() -> int:
|
||||
|
||||
# ---- 2. the questions
|
||||
step(2, "your choices")
|
||||
names = list(MODELS)
|
||||
fams = list(FAMILIES)
|
||||
if a.family:
|
||||
family = a.family
|
||||
else:
|
||||
for i, f in enumerate(fams, 1):
|
||||
d = FAMILIES[f]
|
||||
say(f" {i}) {d['title']:20s} {d['by']} - {d['about']}")
|
||||
family = fams[int(ask("Which model?", [str(i) for i in range(1, len(fams) + 1)], "1", a.yes)) - 1]
|
||||
fam = FAMILIES[family]
|
||||
ok(f"model: {fam['title']}")
|
||||
if fam.get("license"):
|
||||
say(f" Its license: {fam['license']}")
|
||||
say()
|
||||
names = [m for m in MODELS if family in MODELS[m].get("families", FAMILIES)]
|
||||
if a.model and a.model not in names:
|
||||
fail(f"{fam['title']} has no {a.model} model file", "choose one of: " + ", ".join(names))
|
||||
for i, m in enumerate(names, 1):
|
||||
d = MODELS[m]
|
||||
fit = "" if ram >= d["ram_gb"] else f" <- needs {d['ram_gb']} GB RAM, you have {ram:.0f}"
|
||||
say(f" {i}) {m:8s} {d['about']}; download {d['download_gb']:.0f} GB, uses ~{d['arena_gb']:.0f} GB of RAM{fit}")
|
||||
rec = "3" if ram >= 60 else "1"
|
||||
model = a.model or names[int(ask("Which model?", ["1", "2", "3"], rec, a.yes)) - 1]
|
||||
rec = str(names.index("IQ3_XXS") + 1) if ram >= 60 else "1"
|
||||
model = a.model or names[int(ask("Which size?", [str(i) for i in range(1, len(names) + 1)], rec, a.yes)) - 1]
|
||||
if ram < MODELS[model]["ram_gb"] - 4:
|
||||
fail(f"{model} needs about {MODELS[model]['ram_gb']} GB of RAM; this PC has {ram:.0f} GB",
|
||||
"choose Q2_0 or IQ2_XS, or add RAM")
|
||||
ok(f"model: {model}")
|
||||
ok(f"size: {model}")
|
||||
tag = fam["tag"] + model # names of the pack, config and start script
|
||||
rec_ctx = 32768 if gpu["vram_gb"] < 14 else 65536 if gpu["vram_gb"] < 20 else 131072
|
||||
if a.context:
|
||||
ctx = a.context
|
||||
@@ -661,10 +767,22 @@ def main() -> int:
|
||||
for i, c in enumerate(CONTEXTS, 1):
|
||||
say(f" {i}) {c // 1024}K tokens" + (" (recommended for your GPU)" if c == rec_ctx else ""))
|
||||
ctx = CONTEXTS[int(ask("Context?", [str(i) for i in range(1, 6)], str(CONTEXTS.index(rec_ctx) + 1), a.yes)) - 1]
|
||||
if model == "IQ3_XXS" and ram < 90 and ctx > 131072:
|
||||
warn("IQ3_XXS with a 262K context needs more than 64 GB of RAM (43 GB of experts + the context): using 128K")
|
||||
if model in ("IQ3_XXS", "IQ3_S") and ram < 90 and ctx > 131072:
|
||||
warn(f"{model} with a 262K context needs more than 64 GB of RAM ({MODELS[model]['arena_gb']:.0f} GB of experts "
|
||||
"+ the context): using 128K")
|
||||
ctx = 131072
|
||||
ok(f"context: {ctx} tokens")
|
||||
# the KV cache (the model's memory of the conversation): 8-bit, or 4-bit after a Hadamard rotation (PR #21)
|
||||
kv = "fp16" if ctx <= 8192 else (a.kv or "int8")
|
||||
if ctx > 8192 and not a.kv and not a.yes:
|
||||
say()
|
||||
say(" KV cache precision (the model's memory of the conversation):")
|
||||
say(" 1) 8-bit (recommended: what every published number was measured with)")
|
||||
say(" 2) 4-bit half the memory (about 4% faster at 128K), but measurably less precise on long")
|
||||
say(" documents; long-context lookups (needle tests) still pass")
|
||||
kv = ["int8", "q4_0"][int(ask("KV cache?", ["1", "2"], "1", a.yes)) - 1]
|
||||
if ctx > 8192:
|
||||
ok(f"KV cache: {'8-bit' if kv == 'int8' else '4-bit (Hadamard-rotated)'}")
|
||||
if a.vision:
|
||||
vision = {"yes": "gpu", "no": "none"}.get(a.vision, a.vision)
|
||||
else:
|
||||
@@ -673,17 +791,36 @@ def main() -> int:
|
||||
say(" download and keeps ~1.4 GB of VRAM free for the image encoder, so text is a few % slower.")
|
||||
vision = "gpu" if ask("Do you want images?", ["y", "n"], "n", a.yes) == "y" else "none"
|
||||
ok("images: " + {"none": "off", "gpu": "on", "cpu": "on (encoder on the CPU)"}[vision])
|
||||
models_dir = Path(a.gguf_dir) if a.gguf_dir else Path(a.models_dir) / model
|
||||
shards = [models_dir / f"Qwen3.8-Flash-Next-GSQ-RCO-{model}-0000{i}-of-00002.gguf" for i in (1, 2)]
|
||||
# EXPERIMENTAL: the experimental-speed-projection control vector (data/experimental-speed-projection), off unless
|
||||
# chosen here; with it loaded, the web app and the API switch it off per request
|
||||
esp = None
|
||||
esp_choice = (a.experimental_speed_projection or "").strip()
|
||||
if family == "qwen":
|
||||
if not esp_choice:
|
||||
say()
|
||||
say(" EXPERIMENTAL - speed projection: a small control vector applied while the model runs (layers 4-44).")
|
||||
say(" It changes how the model answers: its package describes it as a refusal-direction projection (the")
|
||||
say(" model declines far fewer requests). Off unless you choose it; when on, the web app can switch it off")
|
||||
say(" per chat. Details: data/experimental-speed-projection/README.md")
|
||||
esp_choice = "on" if ask("Turn on the experimental speed projection?", ["y", "n"], "n", a.yes) == "y" else "off"
|
||||
if esp_choice.lower() not in ("off", "no", "n", "0"):
|
||||
esp = ESP_VECTOR if esp_choice.lower() in ("on", "yes", "y", "1") else Path(esp_choice).expanduser().resolve()
|
||||
if not esp.is_file():
|
||||
fail(f"the experimental speed projection's vector is missing: {esp}")
|
||||
ok("experimental speed projection: " + ("ON (experimental)" if esp else "off"))
|
||||
elif esp_choice.lower() not in ("", "off", "no", "n", "0"):
|
||||
warn("the experimental speed projection is made for the original Qwen3.8-Flash-Next, not Swift 1.5: left off")
|
||||
models_dir = Path(a.gguf_dir) if a.gguf_dir else Path(a.models_dir) / tag
|
||||
shards = [models_dir / fam["file"].format(q=model, i=i) for i in (1, 2)]
|
||||
have_model = all(s.exists() and (done(s) or a.gguf_dir) for s in shards)
|
||||
need = (0 if a.gguf_dir or have_model else MODELS[model]["download_gb"]) + 8 + \
|
||||
(40 if model == "Q2_0" and avx512 else 0) + (1 if vision != "none" else 0)
|
||||
(40 if model == "Q2_0" and avx512 and family == "qwen" else 0) + (1 if vision != "none" else 0)
|
||||
if free_gb(models_dir) < need:
|
||||
fail(f"not enough free disk space in {models_dir}: need ~{need:.0f} GB", "use --models-dir on a bigger drive")
|
||||
|
||||
# ---- 3. python packages
|
||||
step(3, "Python packages")
|
||||
pip_install(PY_PACKAGES, "numpy, jinja2, regex, pyyaml, tqdm, requests, cmake, ninja")
|
||||
pip_install(PY_PACKAGES, "numpy, jinja2, regex, pyyaml, tqdm, requests, cmake, ninja, pillow, psutil")
|
||||
|
||||
# ---- 4. the engine
|
||||
step(4, "the Strata engine")
|
||||
@@ -702,15 +839,15 @@ def main() -> int:
|
||||
ok(f"engine: {eng / EXE}")
|
||||
|
||||
# ---- 5. the model files
|
||||
step(5, f"downloading {model}")
|
||||
step(5, f"downloading {fam['title']} {model}")
|
||||
if not a.gguf_dir:
|
||||
for s in shards:
|
||||
if s.exists() and done(s):
|
||||
ok(f"{s.name} already downloaded")
|
||||
continue
|
||||
# shard 2 is the same file for all three models: reuse one that is already here
|
||||
# the original's shard 2 is the same file for all three sizes: reuse one that is already here
|
||||
other = [p for p in Path(a.models_dir).glob("*/Qwen3.8-Flash-Next-GSQ-RCO-*-00002-of-00002.gguf") if done(p)]
|
||||
if s.name.endswith("00002-of-00002.gguf") and other and not s.exists():
|
||||
if family == "qwen" and s.name.endswith("00002-of-00002.gguf") and other and not s.exists():
|
||||
try:
|
||||
os.link(other[0], s)
|
||||
mark(s)
|
||||
@@ -718,24 +855,24 @@ def main() -> int:
|
||||
continue
|
||||
except OSError:
|
||||
pass
|
||||
download(HF + f"{model}/{s.name}", s)
|
||||
download(fam["hf"].format(q=model) + s.name, s)
|
||||
for s in shards:
|
||||
if not s.exists():
|
||||
fail(f"missing {s}")
|
||||
ok("model files present")
|
||||
mmproj = Path(a.models_dir) / MMPROJ
|
||||
mmproj = Path(a.models_dir) / fam["mmproj"]
|
||||
if vision != "none":
|
||||
if not mmproj.exists() and a.gguf_dir and (Path(a.gguf_dir) / MMPROJ).exists():
|
||||
mmproj = Path(a.gguf_dir) / MMPROJ
|
||||
if not mmproj.exists() and a.gguf_dir and (Path(a.gguf_dir) / fam["mmproj"]).exists():
|
||||
mmproj = Path(a.gguf_dir) / fam["mmproj"]
|
||||
else:
|
||||
download(HF + MMPROJ, mmproj, "vision encoder")
|
||||
download(fam["mmproj_hf"] + fam["mmproj"], mmproj, "vision encoder")
|
||||
ok(f"vision encoder: {mmproj}")
|
||||
|
||||
# ---- 6. the pack and the MTP draft layer
|
||||
step(6, "preparing the model for Strata")
|
||||
pack = ROOT / "packs" / model.lower()
|
||||
pack = ROOT / "packs" / tag.lower()
|
||||
env = dict(os.environ, STRATA_GGUF_PY=str(llama / "gguf-py"))
|
||||
if model == "Q2_0" and avx512:
|
||||
if model == "Q2_0" and avx512 and family == "qwen":
|
||||
# the Q2_0 experts repacked for the AVX-512 kernel (the measured speed): a one-time ~40 GB conversion
|
||||
if not (pack / "index.txt").exists() or not (pack / "experts.bin").exists(): # index.txt is written last
|
||||
say(" Converting the Q2_0 experts for the AVX-512 kernel (one time, ~40 GB written, 2-5 min) ...")
|
||||
@@ -765,31 +902,54 @@ def main() -> int:
|
||||
|
||||
# ---- 7. the start script
|
||||
step(7, "writing the start script")
|
||||
args = ["--pack", str(pack), "--native", str(shards[0]), "--ple-gguf", str(shards[1]),
|
||||
sys.path.insert(0, str(ROOT / "tools"))
|
||||
from gguf_reader import GGUFFile # the PLE table's shard: shard 2 (original) or 1 (Swift)
|
||||
ple = next((s for s in shards if any(t.name == "per_layer_token_embd.weight" for t in GGUFFile(s).tensors)), None)
|
||||
if ple is None:
|
||||
fail("the model has no per_layer_token_embd tensor (is this a Qwen3.8-Flash-Next GGUF?)")
|
||||
args = ["--pack", str(pack), "--native", str(shards[0]), "--ple-gguf", str(ple),
|
||||
"--expert-profile", str(ROOT / "data" / "expert-profile.bin"), "--expert-cache", "auto",
|
||||
"--prefill", "2048", "--spec", "4", "--spec-min-p", "0.5", "--mtp", str(rt),
|
||||
"--max-context", str(ctx)]
|
||||
if ctx > 8192:
|
||||
args += ["--kv", "int8"]
|
||||
args += ["--kv", kv]
|
||||
# KV streaming: from 64K up the whole KV cache lives in RAM and only the part the attention reads (32K positions
|
||||
# per layer) stays in VRAM; the VRAM it frees holds more experts (+6% at 128K, +23% at 262K with Q2_0). It
|
||||
# costs ~13.7 KB of RAM per context token with 8-bit KV (1.7 GB at 128K), 7.5 KB with 4-bit, so only when it fits.
|
||||
kv_ram_gb = ctx * (13 * (576 if kv == "q4_0" else 1056)) / 1e9 # 12 QSA layers + the draft layer
|
||||
if ctx >= 65536 and ram >= MODELS[model]["ram_gb"] + kv_ram_gb + 1:
|
||||
args += ["--kv-resident", "32768"]
|
||||
ok(f"KV streaming on: the context's KV cache lives in RAM ({kv_ram_gb:.1f} GB), more experts fit in VRAM")
|
||||
if vision != "none":
|
||||
args += ["--vision", "--vram-reserve-mib", str(VISION[vision]["reserve_mib"])]
|
||||
if esp is not None:
|
||||
# the package's profile, with llama.cpp's flags (the engine takes the same ones)
|
||||
args += ["--control-vector-scaled", f"{esp}:1.0", "--control-vector-layer-range", "4", "44",
|
||||
"--cvec-mode", "project", "--cvec-dir", "per-layer"]
|
||||
cfg = {"exe": str(eng / EXE), "args": args, "cwd": str(ROOT), "tokenizer": str(pack / "tokenizer"),
|
||||
"model_name": f"qwen3.8-flash-next-{model.lower()}", "log": str(ROOT / f"strata-{model.lower()}.log"),
|
||||
"model_name": f"{fam['name']}-{model.lower()}", "log": str(ROOT / f"strata-{tag.lower()}.log"),
|
||||
"lib_dirs": lib_dirs, "port": a.port}
|
||||
if a.host:
|
||||
cfg["host"] = a.host
|
||||
if a.api_key:
|
||||
cfg["api_key"] = a.api_key
|
||||
if vision != "none":
|
||||
cfg["vision"] = {"exe": str(eng / VEXE), "mmproj": str(mmproj), "model": str(shards[0]),
|
||||
"gpu": vision == "gpu", "max_tokens": VISION[vision]["max_tokens"]}
|
||||
if vision == "cpu":
|
||||
cfg["vision"]["threads"] = max(1, (os.cpu_count() or 8) // 2)
|
||||
cfg_path = ROOT / f"strata-{model.lower()}.json"
|
||||
cfg_path = ROOT / f"strata-{tag.lower()}.json"
|
||||
cfg_path.write_text(json.dumps(cfg, indent=1), encoding="utf-8")
|
||||
script = write_run_script(model, cfg_path, a.port)
|
||||
script = write_run_script(tag, cfg_path, a.port)
|
||||
ok(f"start script: {script.name}")
|
||||
|
||||
say()
|
||||
say("All set.")
|
||||
say(f" API (OpenAI): http://127.0.0.1:{a.port}/v1 (any API key; model name: anything)")
|
||||
say(f" API (Anthropic): http://127.0.0.1:{a.port}/v1/messages")
|
||||
if a.host and a.host not in ("127.0.0.1", "localhost"):
|
||||
say(f" Other devices: the server window prints this PC's address (http://<IP>:{a.port}/)"
|
||||
+ ("" if a.api_key else " - no API key set: anyone on your network can use it"))
|
||||
say(f" Next time: just run {'START-HERE.bat' if WIN else './setup.sh'} (or {script.name}) - it starts right away")
|
||||
if vision != "none":
|
||||
say(" Images: send them in the chat page, in chat.py (/image <path>) or over the API")
|
||||
|
||||
@@ -13,6 +13,7 @@
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
#include <thread>
|
||||
@@ -263,8 +264,14 @@ void expert_pool_dispatch_multi(ExpertDispatch& d, const float* x_f, const int32
|
||||
if (native && d.nact_multi.size() < (size_t) MAXT * kNativeActBytes) d.nact_multi.resize((size_t) MAXT * kNativeActBytes);
|
||||
if (d.job_of.size() != (size_t) d.n_expert) d.job_of.assign((size_t) d.n_expert, (int16_t) -1);
|
||||
if (d.jobs_multi.size() < (size_t) (n_tok * k)) d.jobs_multi.resize((size_t) (MAXT * k));
|
||||
static const bool ptrace = std::getenv("STRATA_POOL_TRACE") != nullptr;
|
||||
auto pt = [&](const char* what, long long a = -1) {
|
||||
if (ptrace) { std::fprintf(stderr, "pool trace: layer %lld %s %lld\n", (long long) d.layers, what, a); std::fflush(stderr); }
|
||||
};
|
||||
const auto c0 = std::chrono::steady_clock::now();
|
||||
pt("begin");
|
||||
d.src->begin_layer(d.layers, ids, n_tok * k);
|
||||
pt("begun");
|
||||
if (!d.usage.empty())
|
||||
for (int64_t i = 0; i < n_tok * k; ++i)
|
||||
if (ids[i] >= 0 && ids[i] < d.n_expert) d.usage[(size_t) d.layers * (size_t) d.n_expert + (size_t) ids[i]] += 1.0f;
|
||||
@@ -348,7 +355,9 @@ void expert_pool_dispatch_multi(ExpertDispatch& d, const float* x_f, const int32
|
||||
P.counts[1] = entries;
|
||||
P.counts[2] = fetches;
|
||||
std::atomic_thread_fence(std::memory_order_seq_cst);
|
||||
pt("publish", fetches);
|
||||
if (P.publish) P.publish(P.ctx);
|
||||
pt("fetch", fetches);
|
||||
if (P.fetch) P.fetch(P.ctx, dma_src, P.pcie_mode != 0 ? 0 : fetches, (size_t) bb); // the copy engine, beside the CPU's work
|
||||
} else {
|
||||
for (int64_t i = 0; i < n; ++i) {
|
||||
@@ -409,9 +418,11 @@ void expert_pool_dispatch_multi(ExpertDispatch& d, const float* x_f, const int32
|
||||
++d.multi_entries;
|
||||
}
|
||||
const auto c3 = std::chrono::steady_clock::now();
|
||||
pt("run", njobs);
|
||||
if (native) d.pool->run_split_multi_native(lay.fmt[(size_t) d.layers], d.jobs_multi.data(), njobs);
|
||||
else d.pool->run_split_multi(d.jobs_multi.data(), njobs);
|
||||
const auto c4 = std::chrono::steady_clock::now();
|
||||
pt("ran");
|
||||
auto ms = [](auto a, auto b) { return std::chrono::duration<double, std::milli>(b - a).count(); };
|
||||
d.ms_plan += ms(c0, c1);
|
||||
d.ms_actq += ms(c1, c2);
|
||||
@@ -545,13 +556,28 @@ LoadStats load_experts_gguf(const std::string& gguf, uint8_t* dst, const strata:
|
||||
const auto t0 = std::chrono::steady_clock::now();
|
||||
std::atomic<int64_t> next{0};
|
||||
std::atomic<bool> bad{false};
|
||||
// a layer's experts may sit in another shard of the model (native_experts.txt v3): a name beside `gguf`
|
||||
const size_t cut = gguf.find_last_of("/\\");
|
||||
const std::string dir = cut == std::string::npos ? std::string() : gguf.substr(0, cut + 1);
|
||||
auto file_of = [&](int64_t l) -> std::string {
|
||||
if (lay.gguf_file.empty() || lay.gguf_file[(size_t) l].empty()) return gguf;
|
||||
return dir + lay.gguf_file[(size_t) l];
|
||||
};
|
||||
auto worker = [&]() {
|
||||
std::ifstream f(gguf, std::ios::binary);
|
||||
if (!f) { bad = true; return; }
|
||||
std::ifstream f;
|
||||
std::string open_name;
|
||||
std::vector<uint8_t> buf;
|
||||
for (;;) {
|
||||
const int64_t l = next.fetch_add(1);
|
||||
if (l >= lay.n_layers || bad) break;
|
||||
const std::string name = file_of(l);
|
||||
if (name != open_name) {
|
||||
f.close();
|
||||
f.clear();
|
||||
f.open(name, std::ios::binary);
|
||||
if (!f) { bad = true; return; }
|
||||
open_name = name;
|
||||
}
|
||||
const auto& fm = lay.fmt[(size_t) l];
|
||||
const uint64_t blob = lay.bytes[(size_t) l];
|
||||
const uint64_t per[3] = {fm.up_off, fm.up_off, blob - fm.down_off};
|
||||
|
||||
+251
-44
@@ -7,6 +7,7 @@
|
||||
#include "strata/kernels/elementwise.hpp"
|
||||
#include "strata/kernels/gdn.hpp"
|
||||
#include "strata/kernels/qsa.hpp"
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
#include "strata/kernels/kv_q8.hpp"
|
||||
#include "strata/kernels/quantize_act.hpp"
|
||||
#include "strata/kernels/rope.hpp"
|
||||
@@ -24,9 +25,12 @@
|
||||
#include "strata/kernels/native_rope.hpp"
|
||||
#include "strata/kernels/native_flash_attn.hpp"
|
||||
#include "strata/kernels/fused_gr.hpp"
|
||||
#include "strata/kernels/cvec.hpp"
|
||||
#include "strata/kernels/qsa_decode_attn.hpp"
|
||||
#include "strata/kernels/fused_gdn.hpp"
|
||||
#include "strata/kernels/qsa_select.hpp"
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <exception>
|
||||
#include <cuda_runtime.h>
|
||||
#include <cmath>
|
||||
@@ -168,9 +172,11 @@ if (!w.wants_q8k()) { s_gemv_q8_0_split(x80, p.codes, p.scales, p.offset,
|
||||
// namespace
|
||||
void layer_set_native_bf16(bool enabled) { native_bf16_projections = enabled; }
|
||||
void layer_set_native_flash_attn_short(bool enabled) { native_flash_attn_short = enabled; }
|
||||
namespace { bool g_kv_int8 = false; }
|
||||
namespace { bool g_kv_int8 = false, g_kv_q4 = false; }
|
||||
void qsa_set_kv_int8(bool enabled) { g_kv_int8 = enabled; }
|
||||
bool qsa_kv_int8() { return g_kv_int8; }
|
||||
void qsa_set_kv_q4(bool enabled) { g_kv_q4 = enabled; }
|
||||
bool qsa_kv_q4() { return g_kv_q4; }
|
||||
uint64_t gdn_buffers_bytes(const ModelGeometry& g) { const int64_t C = g.ssm_conv_channels; const int64_t V = g.ssm_value_dim; const uint64_t parts[] = { q8k_bytes(g.n_embd),
|
||||
// x_q8k
|
||||
(uint64_t) (g.n_embd / 32) * 34,
|
||||
@@ -475,39 +481,220 @@ struct Cursor { uint8_t* p; uint64_t used = 0; template <typename T>
|
||||
// dispatch too and the two must not be able to drift.
|
||||
}
|
||||
// namespace
|
||||
uint64_t qsa_state_bytes(const ModelGeometry& g, int64_t max_cells, bool with_rope) { const QsaShapes s = qsa_shapes(g); const int64_t pages = (max_cells + s.page_size - 1) / s.page_size; uint64_t n = 0; n += g_kv_int8 ? (uint64_t) pages * s.page_size * strata::kernels::kv_q8_bytes_per_cell(s) + 64 : (uint64_t) pages * s.n_head_kv * s.page_size * s.head_dim * 2 * 2;
|
||||
// k_pool + v_pool, fp16
|
||||
n += (uint64_t) pages * 4;
|
||||
// page_table
|
||||
n += (uint64_t) (s.idx_block - 1) * s.idx_dim * 4;
|
||||
// tail
|
||||
n += (uint64_t) s.idx_dim * 4;
|
||||
// dead
|
||||
n += (uint64_t) ((max_cells / s.idx_block) + 2) * s.idx_dim * 4;
|
||||
// pooled
|
||||
n += 16;
|
||||
// block_pos
|
||||
if (with_rope) n += (uint64_t) max_cells * (s.n_rot / 2) * 4 * 2;
|
||||
// cos + sin tables
|
||||
n += strata::kernels::qsa_step_bytes() + 16; // counts and aligned attention status
|
||||
// the per-token counts
|
||||
n += (uint64_t) s.n_head * 4;
|
||||
// pos_dev
|
||||
return align_up16(n) + 256;}
|
||||
uint64_t qsa_state_init(const ModelGeometry& g, int64_t max_cells, void* base, QsaState& st, const QsaState* share_rope) { const QsaShapes s = qsa_shapes(g); const int64_t pages = (max_cells + s.page_size - 1) / s.page_size; Cursor c{(uint8_t*) base}; st.kv_int8 = g_kv_int8; if (g_kv_int8) { const uint64_t cells = (uint64_t) pages * s.n_head_kv * s.page_size; st.k_q = c.take<int8_t>(cells * s.head_dim); st.v_q = c.take<int8_t>(cells * s.head_dim); st.k_scale = c.take<uint16_t>(cells * (s.head_dim / strata::kernels::KV_Q8_GROUP)); st.v_scale = c.take<uint16_t>(cells * (s.head_dim / strata::kernels::KV_Q8_GROUP)); } else { st.k_pool = c.take<uint16_t>((uint64_t) pages * s.n_head_kv * s.page_size * s.head_dim); st.v_pool = c.take<uint16_t>((uint64_t) pages * s.n_head_kv * s.page_size * s.head_dim); } st.page_table = c.take<int32_t>((uint64_t) pages); st.n_pages = pages; st.max_cells = max_cells; st.idx_tail = c.take<float>((uint64_t) (s.idx_block - 1) * s.idx_dim); st.idx_dead = c.take<float>((uint64_t) s.idx_dim); st.idx_pooled = c.take<float>((uint64_t) ((max_cells / s.idx_block) + 2) * s.idx_dim); st.idx_block_pos = c.take<int32_t>(1); if (share_rope != nullptr) { st.cos_tab = share_rope->cos_tab; st.sin_tab = share_rope->sin_tab; } else { st.cos_tab = c.take<float>((uint64_t) max_cells * (s.n_rot / 2)); st.sin_tab = c.take<float>((uint64_t) max_cells * (s.n_rot / 2)); } st.step = c.take<int32_t>((uint64_t) strata::kernels::kStepCount); st.attention_status = c.take<int32_t>(1); st.pos_dev = c.take<int32_t>((uint64_t) s.n_head);
|
||||
// the pinned staging the uploads copy FROM - see the note on `host_step` in the header
|
||||
if (cudaHostAlloc((void**) &st.host_step, strata::kernels::qsa_step_bytes() + sizeof(int32_t), cudaHostAllocMapped | cudaHostAllocPortable) != cudaSuccess || cudaHostAlloc((void**) &st.host_pos, (size_t) s.n_head * 4, cudaHostAllocMapped | cudaHostAllocPortable) != cudaSuccess) { return 0;
|
||||
// the caller sees a zero byte count; a half-built state is worse than none
|
||||
namespace {
|
||||
// KV streaming (docs/kv-streaming-design.md): 0 keeps every cell in VRAM.
|
||||
int64_t g_kv_resident = 0;
|
||||
uint64_t g_kv_host_bytes = 0;
|
||||
|
||||
/// How one state holds its K/V: `mode` as in QsaState::kv_mode, `slots` VRAM pages of `pages` logical ones.
|
||||
struct KvPlan {
|
||||
int mode = 0;
|
||||
int64_t pages = 0, slots = 0, pooled_rows = 0;
|
||||
};
|
||||
KvPlan kv_plan(const QsaShapes& s, int64_t max_cells, int64_t ring_cells) {
|
||||
KvPlan p;
|
||||
p.pages = (max_cells + s.page_size - 1) / s.page_size;
|
||||
p.slots = p.pages;
|
||||
p.pooled_rows = max_cells / s.idx_block + 2;
|
||||
if (g_kv_resident <= 0 || ring_cells < 0) return p; // ring_cells < 0: always fully resident
|
||||
// A/B only: STRATA_KV_RING_OFF keeps the drafter fully resident, STRATA_KV_MAIN_OFF the main layers
|
||||
static const bool ring_off = std::getenv("STRATA_KV_RING_OFF") != nullptr;
|
||||
static const bool main_off = std::getenv("STRATA_KV_MAIN_OFF") != nullptr;
|
||||
if (ring_cells > 0 ? ring_off : main_off) return p;
|
||||
if (ring_cells > 0) {
|
||||
const int64_t r = (ring_cells + s.page_size - 1) / s.page_size;
|
||||
if (r < p.pages) { p.mode = 2; p.slots = r; p.pooled_rows = 2; } // the drafter has no indexer
|
||||
} else {
|
||||
const int64_t r = (std::max(g_kv_resident, qsa_kv_resident_min()) + s.page_size - 1) / s.page_size;
|
||||
if (r < p.pages) { p.mode = 1; p.slots = r; }
|
||||
}
|
||||
return p;
|
||||
}
|
||||
st.host_step[strata::kernels::kStepCount] = 0;
|
||||
// THE ROPE TABLE IS BUILT ON THE HOST IN FLOAT64 and uploaded once, because the reference computes its
|
||||
// frequencies in float64 and reproducing that on device means double-precision `pow`/`cos` that need not
|
||||
// agree with the host's libm. A table shorter than the sequence would have the rotation read past it.
|
||||
if (share_rope == nullptr) { std::vector<float> hc((size_t) max_cells * (s.n_rot / 2)), hs((size_t) max_cells * (s.n_rot / 2)); strata::kernels::build_rope_table((int) s.n_rot, strata::kernels::qsa_freq_base(), (int) max_cells, hc.data(), hs.data()); cudaMemcpy(st.cos_tab, hc.data(), hc.size() * 4, cudaMemcpyHostToDevice); cudaMemcpy(st.sin_tab, hs.data(), hs.size() * 4, cudaMemcpyHostToDevice); }
|
||||
// the page table starts as the IDENTITY, which is the simplest legal mapping and what a caller that does
|
||||
// not page at all wants. A real allocator re-points it; nothing outside `kv_append`/`kv_gather` may care.
|
||||
std::vector<int32_t> tab((size_t) pages); for (int64_t i = 0; i < pages; ++i) tab[(size_t) i] = (int32_t) i; cudaMemcpy(st.page_table, tab.data(), tab.size() * 4, cudaMemcpyHostToDevice); return c.used;}
|
||||
void qsa_state_zero(const QsaState& st, const ModelGeometry& g, void* stream) { const QsaShapes s = qsa_shapes(g); cudaStream_t cs = (cudaStream_t) stream; if (st.kv_int8) { const size_t cells = (size_t) st.n_pages * s.n_head_kv * s.page_size; cudaMemsetAsync(st.k_q, 0, cells * s.head_dim, cs); cudaMemsetAsync(st.v_q, 0, cells * s.head_dim, cs); cudaMemsetAsync(st.k_scale, 0, cells * (s.head_dim / strata::kernels::KV_Q8_GROUP) * 2, cs); cudaMemsetAsync(st.v_scale, 0, cells * (s.head_dim / strata::kernels::KV_Q8_GROUP) * 2, cs); } else { cudaMemsetAsync(st.k_pool, 0, (size_t) st.n_pages * s.n_head_kv * s.page_size * s.head_dim * 2, cs); cudaMemsetAsync(st.v_pool, 0, (size_t) st.n_pages * s.n_head_kv * s.page_size * s.head_dim * 2, cs); } cudaMemsetAsync(st.idx_tail, 0, (size_t) (s.idx_block - 1) * s.idx_dim * 4, cs); cudaMemsetAsync(st.idx_dead, 0, (size_t) s.idx_dim * 4, cs); cudaMemsetAsync(st.idx_pooled, 0, (size_t) ((st.max_cells / s.idx_block) + 2) * s.idx_dim * 4, cs);}
|
||||
uint64_t kv_pool_bytes(const QsaShapes& s, int64_t pages) {
|
||||
if (g_kv_q4) return (uint64_t) pages * s.page_size * strata::kernels::kv_q4_bytes_per_cell(s) + 64;
|
||||
return g_kv_int8 ? (uint64_t) pages * s.page_size * strata::kernels::kv_q8_bytes_per_cell(s) + 64
|
||||
: (uint64_t) pages * s.n_head_kv * s.page_size * s.head_dim * 2 * 2;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void qsa_set_kv_resident(int64_t cells) { g_kv_resident = cells > 0 ? cells : 0; }
|
||||
int64_t qsa_kv_resident() { return g_kv_resident; }
|
||||
int64_t qsa_kv_resident_min() { return 20480; }
|
||||
uint64_t qsa_kv_host_bytes() { return g_kv_host_bytes; }
|
||||
|
||||
uint64_t qsa_state_bytes(const ModelGeometry& g, int64_t max_cells, bool with_rope, int64_t ring_cells) {
|
||||
const QsaShapes s = qsa_shapes(g);
|
||||
const KvPlan p = kv_plan(s, max_cells, ring_cells);
|
||||
uint64_t n = 0;
|
||||
n += kv_pool_bytes(s, p.slots) + 4 * 16; // K/V pools (the VRAM slots)
|
||||
n += (uint64_t) p.pages * 4; // page_table
|
||||
if (p.mode == 1) n += strata::kernels::kv_stream_map_bytes(p.slots) + 6 * 16; // the residency map
|
||||
n += (uint64_t) (s.idx_block - 1) * s.idx_dim * 4; // tail
|
||||
n += (uint64_t) s.idx_dim * 4; // dead
|
||||
n += (uint64_t) p.pooled_rows * s.idx_dim * 4; // pooled
|
||||
n += 16; // block_pos
|
||||
if (with_rope) n += (uint64_t) max_cells * (s.n_rot / 2) * 4 * 2; // cos + sin tables
|
||||
n += strata::kernels::qsa_step_bytes() + 16; // counts and aligned attention status
|
||||
n += (uint64_t) s.n_head * 4; // pos_dev
|
||||
return align_up16(n) + 256;
|
||||
}
|
||||
|
||||
uint64_t qsa_state_init(const ModelGeometry& g, int64_t max_cells, void* base, QsaState& st,
|
||||
const QsaState* share_rope, int64_t ring_cells) {
|
||||
const QsaShapes s = qsa_shapes(g);
|
||||
const KvPlan p = kv_plan(s, max_cells, ring_cells);
|
||||
const int64_t pages = p.pages;
|
||||
Cursor c{(uint8_t*) base};
|
||||
st.kv_int8 = g_kv_int8 && !g_kv_q4;
|
||||
st.kv_q4 = g_kv_q4;
|
||||
st.kv_mode = p.mode;
|
||||
st.n_slots = p.slots;
|
||||
const uint64_t rows = (uint64_t) p.slots * s.n_head_kv * s.page_size; // VRAM rows: the slots
|
||||
const uint64_t q4_row = strata::kernels::kv_q4_bytes_per_head((int) s.head_dim);
|
||||
if (st.kv_q4) {
|
||||
st.k_q4 = c.take<uint8_t>(rows * q4_row);
|
||||
st.v_q4 = c.take<uint8_t>(rows * q4_row);
|
||||
} else if (g_kv_int8) {
|
||||
st.k_q = c.take<int8_t>(rows * s.head_dim);
|
||||
st.v_q = c.take<int8_t>(rows * s.head_dim);
|
||||
st.k_scale = c.take<uint16_t>(rows * (s.head_dim / strata::kernels::KV_Q8_GROUP));
|
||||
st.v_scale = c.take<uint16_t>(rows * (s.head_dim / strata::kernels::KV_Q8_GROUP));
|
||||
} else {
|
||||
st.k_pool = c.take<uint16_t>(rows * s.head_dim);
|
||||
st.v_pool = c.take<uint16_t>(rows * s.head_dim);
|
||||
}
|
||||
st.page_table = c.take<int32_t>((uint64_t) pages);
|
||||
st.n_pages = pages;
|
||||
st.max_cells = max_cells;
|
||||
st.map = strata::kernels::KvStreamMap{};
|
||||
st.map.page_table = st.page_table;
|
||||
st.map.n_blocks = pages;
|
||||
st.map.n_slots = p.slots;
|
||||
if (p.mode == 1) {
|
||||
st.map.slot_block = c.take<int32_t>((uint64_t) p.slots);
|
||||
st.map.slot_stamp = c.take<int32_t>((uint64_t) p.slots);
|
||||
st.map.slot_ref = c.take<int32_t>((uint64_t) p.slots);
|
||||
st.map.miss_block = c.take<int32_t>((uint64_t) p.slots);
|
||||
st.map.miss_slot = c.take<int32_t>((uint64_t) p.slots);
|
||||
st.map.ctl = c.take<int32_t>((uint64_t) strata::kernels::kKvCtlInts);
|
||||
}
|
||||
st.idx_tail = c.take<float>((uint64_t) (s.idx_block - 1) * s.idx_dim);
|
||||
st.idx_dead = c.take<float>((uint64_t) s.idx_dim);
|
||||
st.idx_pooled_rows = p.pooled_rows;
|
||||
st.idx_pooled = c.take<float>((uint64_t) p.pooled_rows * s.idx_dim);
|
||||
st.idx_block_pos = c.take<int32_t>(1);
|
||||
if (share_rope != nullptr) {
|
||||
st.cos_tab = share_rope->cos_tab;
|
||||
st.sin_tab = share_rope->sin_tab;
|
||||
} else {
|
||||
st.cos_tab = c.take<float>((uint64_t) max_cells * (s.n_rot / 2));
|
||||
st.sin_tab = c.take<float>((uint64_t) max_cells * (s.n_rot / 2));
|
||||
}
|
||||
st.step = c.take<int32_t>((uint64_t) strata::kernels::kStepCount);
|
||||
st.attention_status = c.take<int32_t>(1);
|
||||
st.pos_dev = c.take<int32_t>((uint64_t) s.n_head);
|
||||
// the pinned staging the uploads copy FROM - see the note on `host_step` in the header
|
||||
if (cudaHostAlloc((void**) &st.host_step, strata::kernels::qsa_step_bytes() + sizeof(int32_t),
|
||||
cudaHostAllocMapped | cudaHostAllocPortable) != cudaSuccess ||
|
||||
cudaHostAlloc((void**) &st.host_pos, (size_t) s.n_head * 4, cudaHostAllocMapped | cudaHostAllocPortable) !=
|
||||
cudaSuccess) {
|
||||
return 0; // the caller sees a zero byte count; a half-built state is worse than none
|
||||
}
|
||||
st.host_step[strata::kernels::kStepCount] = 0;
|
||||
// KV streaming: the authoritative K/V of every cell, pinned and device-mapped, in the identity layout
|
||||
st.host = strata::kernels::KvHostPools{};
|
||||
if (p.mode != 0) {
|
||||
const uint64_t hrows = (uint64_t) pages * s.n_head_kv * s.page_size;
|
||||
const uint64_t bytes = (uint64_t) pages * strata::kernels::kv_block_bytes(s, qsa_kv_format(st)) + 4 * 256;
|
||||
uint8_t* h = nullptr;
|
||||
uint8_t* d = nullptr;
|
||||
if (cudaHostAlloc((void**) &h, bytes, cudaHostAllocMapped | cudaHostAllocPortable) != cudaSuccess ||
|
||||
cudaHostGetDevicePointer((void**) &d, h, 0) != cudaSuccess) {
|
||||
if (p.mode == 1) std::fprintf(stderr, "strata: KV streaming: cannot pin %.2f GiB of RAM for a layer's KV copy "
|
||||
"(lower the context, or run without --kv-resident)\n", (double) bytes / 1073741824.0);
|
||||
return 0;
|
||||
}
|
||||
g_kv_host_bytes += bytes;
|
||||
Cursor hc{d};
|
||||
if (st.kv_q4) {
|
||||
st.host.k_q4 = hc.take<uint8_t>(hrows * q4_row);
|
||||
st.host.v_q4 = hc.take<uint8_t>(hrows * q4_row);
|
||||
} else if (g_kv_int8) {
|
||||
st.host.k_q = hc.take<int8_t>(hrows * s.head_dim);
|
||||
st.host.v_q = hc.take<int8_t>(hrows * s.head_dim);
|
||||
st.host.k_scale = hc.take<uint16_t>(hrows * (s.head_dim / strata::kernels::KV_Q8_GROUP));
|
||||
st.host.v_scale = hc.take<uint16_t>(hrows * (s.head_dim / strata::kernels::KV_Q8_GROUP));
|
||||
} else {
|
||||
st.host.k_pool = hc.take<uint16_t>(hrows * s.head_dim);
|
||||
st.host.v_pool = hc.take<uint16_t>(hrows * s.head_dim);
|
||||
}
|
||||
}
|
||||
// THE ROPE TABLE IS BUILT ON THE HOST IN FLOAT64 and uploaded once, because the reference computes its
|
||||
// frequencies in float64 and reproducing that on device means double-precision `pow`/`cos` that need not
|
||||
// agree with the host's libm. A table shorter than the sequence would have the rotation read past it.
|
||||
if (share_rope == nullptr) {
|
||||
std::vector<float> hc((size_t) max_cells * (s.n_rot / 2)), hs((size_t) max_cells * (s.n_rot / 2));
|
||||
strata::kernels::build_rope_table((int) s.n_rot, strata::kernels::qsa_freq_base(), (int) max_cells,
|
||||
hc.data(), hs.data());
|
||||
cudaMemcpy(st.cos_tab, hc.data(), hc.size() * 4, cudaMemcpyHostToDevice);
|
||||
cudaMemcpy(st.sin_tab, hs.data(), hs.size() * 4, cudaMemcpyHostToDevice);
|
||||
}
|
||||
// the page table starts as the IDENTITY, which is the simplest legal mapping and what a caller that does
|
||||
// not page at all wants; a streamed state starts with nothing resident, a ring at `block % n_slots`.
|
||||
if (p.mode == 0) {
|
||||
std::vector<int32_t> tab((size_t) pages);
|
||||
for (int64_t i = 0; i < pages; ++i) tab[(size_t) i] = (int32_t) i;
|
||||
cudaMemcpy(st.page_table, tab.data(), tab.size() * 4, cudaMemcpyHostToDevice);
|
||||
} else if (p.mode == 1) {
|
||||
strata::kernels::kv_stream_reset(st.map, nullptr);
|
||||
} else {
|
||||
strata::kernels::kv_ring_table(st.page_table, pages, p.slots, nullptr);
|
||||
}
|
||||
cudaDeviceSynchronize();
|
||||
return c.used;
|
||||
}
|
||||
|
||||
void qsa_state_zero(const QsaState& st, const ModelGeometry& g, void* stream) {
|
||||
const QsaShapes s = qsa_shapes(g);
|
||||
cudaStream_t cs = (cudaStream_t) stream;
|
||||
const size_t rows = (size_t) st.n_slots * s.n_head_kv * s.page_size;
|
||||
if (st.kv_q4) {
|
||||
cudaMemsetAsync(st.k_q4, 0, rows * strata::kernels::kv_q4_bytes_per_head((int) s.head_dim), cs);
|
||||
cudaMemsetAsync(st.v_q4, 0, rows * strata::kernels::kv_q4_bytes_per_head((int) s.head_dim), cs);
|
||||
} else if (st.kv_int8) {
|
||||
cudaMemsetAsync(st.k_q, 0, rows * s.head_dim, cs);
|
||||
cudaMemsetAsync(st.v_q, 0, rows * s.head_dim, cs);
|
||||
cudaMemsetAsync(st.k_scale, 0, rows * (s.head_dim / strata::kernels::KV_Q8_GROUP) * 2, cs);
|
||||
cudaMemsetAsync(st.v_scale, 0, rows * (s.head_dim / strata::kernels::KV_Q8_GROUP) * 2, cs);
|
||||
} else {
|
||||
cudaMemsetAsync(st.k_pool, 0, rows * s.head_dim * 2, cs);
|
||||
cudaMemsetAsync(st.v_pool, 0, rows * s.head_dim * 2, cs);
|
||||
}
|
||||
// A streamed state starts over with nothing resident. Its host copy is not cleared (GBs over PCIe per new
|
||||
// conversation): no reader names a cell before this sequence has written it, and a block copied in whole
|
||||
// carries the unwritten cells past the end, which nothing reads.
|
||||
if (st.kv_mode == 1) strata::kernels::kv_stream_reset(st.map, stream);
|
||||
cudaMemsetAsync(st.idx_tail, 0, (size_t) (s.idx_block - 1) * s.idx_dim * 4, cs);
|
||||
cudaMemsetAsync(st.idx_dead, 0, (size_t) s.idx_dim * 4, cs);
|
||||
cudaMemsetAsync(st.idx_pooled, 0, (size_t) st.idx_pooled_rows * s.idx_dim * 4, cs);
|
||||
}
|
||||
|
||||
strata::kernels::QsaAttnPools qsa_attn_pools(const QsaState& st) {
|
||||
strata::kernels::QsaAttnPools pools;
|
||||
pools.page_table = st.page_table;
|
||||
if (st.kv_q4) { pools.k_q4 = st.k_q4; pools.v_q4 = st.v_q4; }
|
||||
else if (st.kv_int8) { pools.k_q = st.k_q; pools.v_q = st.v_q; pools.k_scale = st.k_scale; pools.v_scale = st.v_scale; }
|
||||
else { pools.k_pool = st.k_pool; pools.v_pool = st.v_pool; }
|
||||
return pools;
|
||||
}
|
||||
|
||||
void qsa_kv_resolve(const QsaState& st, const ModelGeometry& g, const int32_t* ids, const int32_t* steps, int64_t n_q,
|
||||
int64_t cap, void* stream) {
|
||||
if (st.kv_mode != 1) return;
|
||||
strata::kernels::kv_stream_resolve(st.map, qsa_attn_pools(st), st.host, qsa_kv_format(st), ids, steps, n_q, cap,
|
||||
qsa_shapes(g), stream);
|
||||
}
|
||||
|
||||
uint64_t qsa_buffers_bytes(const ModelGeometry& g, int64_t max_cells) { const QsaShapes s = qsa_shapes(g); const int64_t cap = strata::kernels::qsa_selection_width(strata::kernels::kTopkMaxCells, s); uint64_t n = 0; n += (uint64_t) q8k_bytes(g.n_embd); n += (uint64_t) (g.n_embd / 32) * 34;
|
||||
// block_q8_0
|
||||
n += (uint64_t) g.n_embd * 2; n += (uint64_t) g.n_head * 2 * g.head_dim * 4; n += (uint64_t) g.n_head * g.head_dim * 4; n += (uint64_t) g.n_head_kv * g.head_dim * 4 * 2; n += (uint64_t) g.idx_key_dim * 4; n += (uint64_t) g.idx_q_heads * g.idx_key_dim * 4; n += (uint64_t) max_cells * 4; n += (uint64_t) cap * 4; n += (uint64_t) cap * g.n_head_kv * g.head_dim * 2 * 2; n += (uint64_t) g.n_head * g.head_dim * 4;
|
||||
@@ -676,7 +863,11 @@ if (!gemv_quantized(*w_attnk, p_k, f_k, b.x_q8_0, b.x_q8k, b.kcur, g.n_embd, g.n
|
||||
// EVERY ENTRY POINT FROM HERE ON IS THE CAPTURABLE ONE: the per-token counts come from `st.step` and every
|
||||
// launch is sized from a capacity in `st`/`b`, so this sequence can be captured and replayed. The
|
||||
// host-scalar wrappers would be correct here today and silently wrong in a graph.
|
||||
if (st.kv_int8) kv_append_q8_step(st.k_q, st.v_q, st.k_scale, st.v_scale, st.page_table, st.step, b.kcur, b.vcur, s, stream); else kv_append_step(st.k_pool, st.v_pool, st.page_table, st.step, b.kcur, b.vcur, s, stream); { const uint64_t nvk = (uint64_t) g.n_head_kv * g.head_dim; const uint64_t base = (uint64_t) 2 * g.n_embd + 2 * g.hc + (uint64_t) g.n_head * g.head_dim + 2 * nvk + 8; if (!st.kv_int8) dump_slot(dump, g, layer, (const float*) st.k_pool, base, nvk / 2, stream); if (!st.kv_int8) dump_slot(dump, g, layer, (const float*) st.v_pool, base + nvk / 2, nvk / 2, stream); dump_slot(dump, g, layer, b.vcur, base + nvk, nvk, stream); dump_slot(dump, g, layer, b.kcur, base + 2 * nvk, nvk, stream); } { const QsaIndexerBuffers ib{st.idx_tail, st.idx_dead, st.idx_pooled, st.idx_block_pos}; if (native_qsa_indexer_enabled()) {
|
||||
if (st.kv_q4) {
|
||||
strata::kernels::fwht256_inplace_cuda(b.kcur, g.n_head_kv, stream); // Q4_0: rotated K and V (kv_q4.hpp)
|
||||
strata::kernels::fwht256_inplace_cuda(b.vcur, g.n_head_kv, stream);
|
||||
strata::kernels::kv_append_q4_step(st.k_q4, st.v_q4, st.page_table, st.step, b.kcur, b.vcur, s, stream, &st.host);
|
||||
} else if (st.kv_int8) kv_append_q8_step(st.k_q, st.v_q, st.k_scale, st.v_scale, st.page_table, st.step, b.kcur, b.vcur, s, stream, &st.host); else kv_append_step(st.k_pool, st.v_pool, st.page_table, st.step, b.kcur, b.vcur, s, stream, &st.host); { const uint64_t nvk = (uint64_t) g.n_head_kv * g.head_dim; const uint64_t base = (uint64_t) 2 * g.n_embd + 2 * g.hc + (uint64_t) g.n_head * g.head_dim + 2 * nvk + 8; if (!st.kv_int8) dump_slot(dump, g, layer, (const float*) st.k_pool, base, nvk / 2, stream); if (!st.kv_int8) dump_slot(dump, g, layer, (const float*) st.v_pool, base + nvk / 2, nvk / 2, stream); dump_slot(dump, g, layer, b.vcur, base + nvk, nvk, stream); dump_slot(dump, g, layer, b.kcur, base + 2 * nvk, nvk, stream); } { const QsaIndexerBuffers ib{st.idx_tail, st.idx_dead, st.idx_pooled, st.idx_block_pos}; if (native_qsa_indexer_enabled()) {
|
||||
try {
|
||||
native_qsa_indexer_append(b.idx_raw, st.step + kStepPos, pos_base,
|
||||
(const float*) w_ikn->data, RMS_EPS, ib, s, st.max_cells, (float) qsa_freq_base(), stream);
|
||||
@@ -708,14 +899,15 @@ int64_t max_blocks = (st.max_cells / s.idx_block) + 2;
|
||||
} else {
|
||||
qsa_index_step(st.idx_pooled, b.q_idx, nullptr, s, st.step, max_blocks, b.cell_scores, stream); topk_512_step(b.cell_scores, s, cap, st.step, b.ids, stream);
|
||||
}
|
||||
// KV streaming: every block the selection names is made resident before anything reads it
|
||||
qsa_kv_resolve(st, g, b.ids, st.step, 1, cap, stream);
|
||||
if (st.kv_q4) strata::kernels::fwht256_inplace_cuda(b.qcur, g.n_head, stream); // <Hq, Hk> = <q, k>
|
||||
if (g_fast_attn && !native_flash_attn_short && dump == nullptr) {
|
||||
strata::kernels::QsaAttnPools pools;
|
||||
pools.k_pool = st.k_pool; pools.v_pool = st.v_pool; pools.k_q = st.k_q; pools.v_q = st.v_q;
|
||||
pools.k_scale = st.k_scale; pools.v_scale = st.v_scale; pools.page_table = st.page_table;
|
||||
if (!st.kv_int8) { pools.k_q = nullptr; pools.v_q = nullptr; }
|
||||
const strata::kernels::QsaAttnPools pools = qsa_attn_pools(st);
|
||||
strata::kernels::qsa_decode_attn_step(b.qcur, pools, b.ids, st.step, cap, s, b.attn_scratch, b.attn, stream);
|
||||
} else {
|
||||
if (st.kv_int8) kv_gather_q8_step(st.k_q, st.v_q, st.k_scale, st.v_scale, st.page_table, b.ids, st.step, cap, s, b.k_scratch, b.v_scratch, stream); else kv_gather_step(st.k_pool, st.v_pool, st.page_table, b.ids, st.step, cap, s, b.k_scratch, b.v_scratch, stream); if (native_flash_attn_short) {
|
||||
if (st.kv_q4) strata::kernels::kv_gather_q4_step(st.k_q4, st.v_q4, st.page_table, b.ids, st.step, cap, s, b.k_scratch, b.v_scratch, stream);
|
||||
else if (st.kv_int8) kv_gather_q8_step(st.k_q, st.v_q, st.k_scale, st.v_scale, st.page_table, b.ids, st.step, cap, s, b.k_scratch, b.v_scratch, stream); else kv_gather_step(st.k_pool, st.v_pool, st.page_table, b.ids, st.step, cap, s, b.k_scratch, b.v_scratch, stream); if (native_flash_attn_short) {
|
||||
if (st.max_cells < 1 || st.max_cells > 256 || !st.attention_status || !st.host_step) {
|
||||
err = v.name("native_flash_attn") + ": short adapter requires context <=256 and persistent status storage";
|
||||
return false;
|
||||
@@ -730,6 +922,7 @@ int64_t max_blocks = (st.max_cells / s.idx_block) + 2;
|
||||
}
|
||||
} else qsa_attend_step(b.qcur, b.k_scratch, b.v_scratch, st.step, cap, s, b.attn, nullptr, stream);
|
||||
}
|
||||
if (st.kv_q4) strata::kernels::fwht256_inplace_cuda(b.attn, g.n_head, stream); // the output back: H is self-inverse
|
||||
dump_slot(dump, g, layer, b.attn, (uint64_t) 2 * g.n_embd + 2 * g.hc, (uint64_t) g.n_head * g.head_dim, stream); { const uint64_t vs = (uint64_t) 2 * g.n_embd + 2 * g.hc + (uint64_t) g.n_head * g.head_dim + (uint64_t) 2 * g.n_head_kv * g.head_dim; dump_slot(dump, g, layer, (const float*) b.v_scratch, vs, (uint64_t) g.n_head_kv * g.head_dim / 2, stream); dump_slot(dump, g, layer, (const float*) b.ids, vs + (uint64_t) g.n_head_kv * g.head_dim / 2, 4, stream); dump_slot(dump, g, layer, (const float*) st.step, vs + (uint64_t) g.n_head_kv * g.head_dim / 2 + 4, 4, stream); }
|
||||
// ---- 9. Gate the attention output before its projection. Native CUDA keeps F32
|
||||
// sigmoid/multiply arithmetic and uses Q8_1 for the native quantized projection.
|
||||
@@ -915,7 +1108,8 @@ bool block_layer_pre(const WeightTable& tables, const ModelGeometry& g, int64_t
|
||||
// the device half: `ple_block` reading `emb_dev`, and the history shift.
|
||||
const bool fused = g_fused_gr && stage_prefix == 0 && half == 0 &&
|
||||
strata::kernels::fused_gr_supported(g.n_embd, g.hc, g.hc_lr);
|
||||
bool pending_ffn = fused && layer > 0; // layer-1's FFN write has not been applied to R yet
|
||||
// layer-1's FFN write has not been applied to R yet - unless a control vector follows it, which needs R
|
||||
bool pending_ffn = fused && layer > 0 && !strata::kernels::cvec().covers(layer - 1);
|
||||
if (ple != nullptr && ple->ready() && layer == 1 && (half == 0 || half == 1)) {
|
||||
if (pending_ffn) {
|
||||
const strata::kernels::GrShapes gs0{g.n_embd, g.hc, g.hc_lr};
|
||||
@@ -1050,10 +1244,23 @@ st_begin(layer, 5, stream);
|
||||
if (g_shared_early ? !moe_combine_parts(g, layer, k, mb, parts, bb.block_out, stream, err)
|
||||
: !moe_finish(tables, g, layer, k, mb, bb.mixed, parts, bb.block_out, stream, err)) return false;
|
||||
st_end(layer, 5, stream); dump_half(bb, g, layer, bb.block_out, (uint64_t) g.n_embd, g.n_embd, stream); dump_half(bb, g, layer, bb.inject, (uint64_t) 2 * g.n_embd + g.hc, g.hc, stream); st_begin(layer, 6, stream);
|
||||
if (!(g_fused_gr && strata::kernels::fused_gr_supported(g.n_embd, g.hc, g.hc_lr)))
|
||||
gr_write(bb.R, bb.block_out, bb.inject, gs, bb.R, stream);
|
||||
else if (layer == g.n_layers - 1)
|
||||
gr_write(bb.R, bb.block_out, bb.inject2, gs, bb.R, stream); // materialise R for the head
|
||||
const bool steer = strata::kernels::cvec().covers(layer); // --control-vector-scaled: after this write
|
||||
try {
|
||||
if (!(g_fused_gr && strata::kernels::fused_gr_supported(g.n_embd, g.hc, g.hc_lr))) {
|
||||
gr_write(bb.R, bb.block_out, bb.inject, gs, bb.R, stream);
|
||||
if (steer) strata::kernels::cvec_apply(bb.R, layer, 1, g.hc * g.n_embd, nullptr, 0, nullptr, 0, false, stream);
|
||||
} else if (layer == g.n_layers - 1) {
|
||||
gr_write(bb.R, bb.block_out, bb.inject2, gs, bb.R, stream); // materialise R for the head
|
||||
if (steer) strata::kernels::cvec_apply(bb.R, layer, 1, g.hc * g.n_embd, nullptr, 0, nullptr, 0, false, stream);
|
||||
} else if (steer) {
|
||||
// the write the next layer's fused read would have folded, then the vector
|
||||
strata::kernels::cvec_apply(bb.R, layer, 1, g.hc * g.n_embd, bb.block_out, g.n_embd, bb.inject2, g.hc,
|
||||
true, stream);
|
||||
}
|
||||
} catch (const std::exception& e) {
|
||||
err = std::string("block_layer_post: ") + e.what();
|
||||
return false;
|
||||
}
|
||||
st_end(layer, 6, stream); return true;}
|
||||
bool block_layer(const WeightTable& tables, const ModelGeometry& g, int64_t layer, int64_t pos, int32_t pos_base, const GdnBuffers& gb, const QsaState& qst, const QsaBuffers& qb, const MoEBuffers& mb, int64_t k, const BlockBuffers& bb, const float* parts, void* stream, std::string& err, const Doorbell* db, const PleRun* ple) {
|
||||
// The two halves back to back. `parts` must be THIS layer's experts and must be ready before the call -
|
||||
|
||||
+38
-10
@@ -7,6 +7,7 @@
|
||||
#include "strata/kernels/elementwise.hpp"
|
||||
#include "strata/kernels/fused_gr.hpp"
|
||||
#include "strata/kernels/gr.hpp"
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
#include "strata/kernels/kv_q8.hpp"
|
||||
#include "strata/kernels/native_moe.hpp"
|
||||
#include "strata/kernels/native_mmvq.hpp"
|
||||
@@ -157,9 +158,23 @@ bool MtpDrafter::load(const std::string& rt_dir, const ModelGeometry& g, Session
|
||||
// ---- the layer's own K/V (dense attention: no indexer state is read)
|
||||
const strata::kernels::QsaShapes s = shapes_of(g);
|
||||
const int64_t max_cells = ss.qsa_states[0].max_cells;
|
||||
const uint64_t sb = qsa_state_bytes(g, max_cells, false);
|
||||
// KV streaming: the drafter only reads its last `window` cells, so with streaming on its K/V is a ring of the
|
||||
// window (plus the cells a round writes ahead of its queries) over a host copy, refilled on a resume. The host copy
|
||||
// is pinned after the expert arena has pinned what it could: if it does not fit, the K/V stays whole in VRAM.
|
||||
int64_t ring = (window > 0 && window < max_cells) ? window + 4 * (int64_t) max_t + 64 : 0;
|
||||
uint64_t sb = qsa_state_bytes(g, max_cells, false, ring);
|
||||
if (cudaMalloc(&state_arena_, sb) != cudaSuccess) { err = "mtp: the K/V state does not fit"; return false; }
|
||||
if (qsa_state_init(g, max_cells, state_arena_, st_, &ss.qsa_states[0]) == 0) { err = "mtp: state init failed"; return false; }
|
||||
if (qsa_state_init(g, max_cells, state_arena_, st_, &ss.qsa_states[0], ring) == 0) {
|
||||
if (st_.kv_mode == 0) { err = "mtp: state init failed"; return false; }
|
||||
std::fprintf(stderr, "strata mtp: no pinned RAM left for the draft layer's K/V copy; keeping it in VRAM\n");
|
||||
cudaGetLastError();
|
||||
cudaFree(state_arena_);
|
||||
st_ = QsaState{};
|
||||
ring = -1; // fully resident
|
||||
sb = qsa_state_bytes(g, max_cells, false, ring);
|
||||
if (cudaMalloc(&state_arena_, sb) != cudaSuccess) { err = "mtp: the K/V state does not fit"; return false; }
|
||||
if (qsa_state_init(g, max_cells, state_arena_, st_, &ss.qsa_states[0], ring) == 0) { err = "mtp: state init failed"; return false; }
|
||||
}
|
||||
qsa_state_zero(st_, g, nullptr);
|
||||
cudaDeviceSynchronize();
|
||||
vram_ += sb;
|
||||
@@ -324,12 +339,17 @@ bool MtpDrafter::record_forward(int T, int step_row0, cudaStream_t cs, std::stri
|
||||
native_mmvq(GGML_Q8_0, q8("self_attn.v_proj.weight"), xq_, vcur_, (int) N, (int) (NKV * HD), T, cs);
|
||||
for (int t = 0; t < T; ++t) {
|
||||
norm_rope(kcur_ + t * NKV * HD, f32("self_attn.k_norm.weight"), (int) NKV, (int) HD, pos + t * NH);
|
||||
if (st_.kv_int8)
|
||||
if (st_.kv_q4) { // Q4_0 KV (kv_q4.hpp): rotated K and V
|
||||
fwht256_inplace_cuda(kcur_ + t * NKV * HD, NKV, cs);
|
||||
fwht256_inplace_cuda(vcur_ + t * NKV * HD, NKV, cs);
|
||||
kv_append_q4_step(st_.k_q4, st_.v_q4, st_.page_table, step + t * 4, kcur_ + t * NKV * HD,
|
||||
vcur_ + t * NKV * HD, s, cs, &st_.host);
|
||||
} else if (st_.kv_int8)
|
||||
kv_append_q8_step(st_.k_q, st_.v_q, st_.k_scale, st_.v_scale, st_.page_table, step + t * 4,
|
||||
kcur_ + t * NKV * HD, vcur_ + t * NKV * HD, s, cs);
|
||||
kcur_ + t * NKV * HD, vcur_ + t * NKV * HD, s, cs, &st_.host);
|
||||
else
|
||||
kv_append_step(st_.k_pool, st_.v_pool, st_.page_table, step + t * 4, kcur_ + t * NKV * HD,
|
||||
vcur_ + t * NKV * HD, s, cs);
|
||||
vcur_ + t * NKV * HD, s, cs, &st_.host);
|
||||
}
|
||||
if (!full) return true;
|
||||
native_mmvq(GGML_Q8_0, q8("self_attn.q_proj.weight"), xq_, qfull_, (int) N, (int) (NH * 2 * HD), T, cs);
|
||||
@@ -341,13 +361,12 @@ bool MtpDrafter::record_forward(int T, int step_row0, cudaStream_t cs, std::stri
|
||||
return false;
|
||||
}
|
||||
norm_rope(qc, f32("self_attn.q_norm.weight"), (int) NH, (int) HD, pos + t * NH);
|
||||
if (st_.kv_q4) fwht256_inplace_cuda(qc, NH, cs);
|
||||
}
|
||||
QsaAttnPools pools;
|
||||
pools.page_table = st_.page_table;
|
||||
if (st_.kv_int8) { pools.k_q = st_.k_q; pools.v_q = st_.v_q; pools.k_scale = st_.k_scale; pools.v_scale = st_.v_scale; }
|
||||
else { pools.k_pool = st_.k_pool; pools.v_pool = st_.v_pool; }
|
||||
const QsaAttnPools pools = qsa_attn_pools(st_);
|
||||
if (window_ > 0) window_ids(const_cast<int32_t*>(step), T, (int) window_, ident_, cap_, cs);
|
||||
qsa_decode_attn_batch(qcur_, pools, ident_, step, cap_, s, attn_scratch_, attn_, T, cs);
|
||||
if (st_.kv_q4) fwht256_inplace_cuda(attn_, (int64_t) T * NH, cs);
|
||||
for (int t = 0; t < T; ++t)
|
||||
native_qsa_gate_apply(attn_ + t * NH * HD, qfull_ + t * NH * 2 * HD, attn32_ + t * NH * HD, (int) NH, (int) HD, cs);
|
||||
native_quantize_q8_1(attn32_, xq_, (int) (NH * HD), T, cs);
|
||||
@@ -491,6 +510,15 @@ bool MtpDrafter::capture_step(int j, std::string& err) {
|
||||
return finish_capture(cs_, ok, step_exec_[j], "step", err);
|
||||
}
|
||||
|
||||
void MtpDrafter::kv_restore(int64_t upto) {
|
||||
if (st_.kv_mode != 2 || upto <= 0) return;
|
||||
// the ring's blocks below `upto`, from the host copy: a checkpoint resume may have left later cells in them
|
||||
const strata::kernels::QsaShapes s = shapes_of(*g_);
|
||||
const int64_t b1 = (upto + s.page_size - 1) / s.page_size, b0 = std::max<int64_t>(0, b1 - st_.n_slots);
|
||||
strata::kernels::kv_ring_restore(qsa_attn_pools(st_), st_.host, qsa_kv_format(st_), b0, b1, st_.n_slots, s, cs_);
|
||||
cudaStreamSynchronize(cs_);
|
||||
}
|
||||
|
||||
bool MtpDrafter::prefill(const float* R_rows, const int32_t* next_tokens, int64_t n, int64_t cell0, std::string& err) {
|
||||
const Clock::time_point t0 = Clock::now();
|
||||
const int64_t HCN = g_->hc * g_->n_embd;
|
||||
@@ -551,7 +579,7 @@ bool MtpDrafter::draft(int T, const int32_t* tokens, int64_t p, int a, int32_t*
|
||||
if (probs) probs[0] = pj;
|
||||
int n = 1;
|
||||
// the chain continues while the last draft is likely enough to be verified
|
||||
for (int j = 1; j < max_t_ - 1 && pj >= min_p; ++j) {
|
||||
for (int j = 1; j < std::min(max_t_ - 1, max_drafts_) && pj >= min_p; ++j) {
|
||||
if (!capture_step(j, err)) return false;
|
||||
put(max_t_ + j - 1, p + a + j);
|
||||
std::atomic_thread_fence(std::memory_order_seq_cst);
|
||||
|
||||
+44
-9
@@ -11,7 +11,9 @@
|
||||
#include "strata/kernels/cpu/expert.hpp"
|
||||
#include "strata/kernels/elementwise.hpp"
|
||||
#include "strata/kernels/fused_gr.hpp"
|
||||
#include "strata/kernels/cvec.hpp"
|
||||
#include "strata/kernels/gr.hpp"
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
#include "strata/kernels/kv_q8.hpp"
|
||||
#include "strata/kernels/native_mmvq.hpp"
|
||||
#include "strata/kernels/native_qsa.hpp"
|
||||
@@ -111,6 +113,8 @@ bool Verifier::init(const WeightTable& wt, const ModelGeometry& g, SessionState&
|
||||
hits_ = hits;
|
||||
head_ = head;
|
||||
max_t_ = max_t;
|
||||
sampling_.greedy = true; // a fresh verifier samples greedily until set_sampling says otherwise
|
||||
sampling_.temperature = 0.0f;
|
||||
if (max_t < 2 || max_t > strata::kernels::kVerifyMaxT || max_t > strata::kernels::cpu::MAXT) {
|
||||
err = "verify: the window must hold 2.." + std::to_string(strata::kernels::kVerifyMaxT) + " tokens";
|
||||
return false;
|
||||
@@ -328,7 +332,9 @@ bool Verifier::record_window(int T, cudaStream_t cs, std::string& err) {
|
||||
wi[h] = need(v, (std::string(pfx[h]) + "inject.weight").c_str(), err);
|
||||
if (!wn[h] || !wd[h] || !wu[h] || !wi[h]) return false;
|
||||
}
|
||||
bool pending = l > 0; // the previous layer's FFN write, folded into this layer's first read
|
||||
// the previous layer's FFN write, folded into this layer's first read (a control vector after it has
|
||||
// already applied it)
|
||||
bool pending = l > 0 && !cvec().covers(l - 1);
|
||||
if (l == 1 && ple_on) {
|
||||
float* normalized = (float*) ((uint8_t*) ss.ple.scratch + ple_block_scratch_bytes());
|
||||
for (int t = tb; t < te; ++t) {
|
||||
@@ -419,15 +425,22 @@ bool Verifier::record_window(int T, cudaStream_t cs, std::string& err) {
|
||||
native_mmvq(wk->native_type, wk->native_data, xq_, kcur_ + tb * NKV * HD, (int) N, (int) (NKV * HD), n, cs);
|
||||
native_mmvq(wv->native_type, wv->native_data, xq_, vcur_ + tb * NKV * HD, (int) N, (int) (NKV * HD), n, cs);
|
||||
for (int t = tb; t < te; ++t) norm_rope(kcur_ + t * NKV * HD, wkn, (int) NKV, (int) HD, pos_ + t * NH);
|
||||
if (st.kv_q4) { // Q4_0 KV (kv_q4.hpp): K and V rotated before they are stored
|
||||
fwht256_inplace_cuda(kcur_ + tb * NKV * HD, (int64_t) n * NKV, cs);
|
||||
fwht256_inplace_cuda(vcur_ + tb * NKV * HD, (int64_t) n * NKV, cs);
|
||||
}
|
||||
if (grp == 0) copy_from_mapped(tail_snap_ + (size_t) qi * TS, st.idx_tail, TS, cs);
|
||||
for (int t = tb; t < te; ++t) {
|
||||
const int32_t* step_t = step_ + t * kStepCount;
|
||||
if (st.kv_int8)
|
||||
if (st.kv_q4)
|
||||
kv_append_q4_step(st.k_q4, st.v_q4, st.page_table, step_t, kcur_ + t * NKV * HD,
|
||||
vcur_ + t * NKV * HD, s, cs, &st.host);
|
||||
else if (st.kv_int8)
|
||||
kv_append_q8_step(st.k_q, st.v_q, st.k_scale, st.v_scale, st.page_table, step_t,
|
||||
kcur_ + t * NKV * HD, vcur_ + t * NKV * HD, s, cs);
|
||||
kcur_ + t * NKV * HD, vcur_ + t * NKV * HD, s, cs, &st.host);
|
||||
else
|
||||
kv_append_step(st.k_pool, st.v_pool, st.page_table, step_t, kcur_ + t * NKV * HD,
|
||||
vcur_ + t * NKV * HD, s, cs);
|
||||
vcur_ + t * NKV * HD, s, cs, &st.host);
|
||||
}
|
||||
const QsaIndexerBuffers ib{st.idx_tail, st.idx_dead, st.idx_pooled, st.idx_block_pos};
|
||||
for (int t = tb; t < te; ++t)
|
||||
@@ -444,6 +457,7 @@ bool Verifier::record_window(int T, cudaStream_t cs, std::string& err) {
|
||||
return false;
|
||||
}
|
||||
norm_rope(qc, wqn, (int) NH, (int) HD, pos_ + t * NH);
|
||||
if (st.kv_q4) fwht256_inplace_cuda(qc, NH, cs); // <Hq, Hk> = <q, k>
|
||||
}
|
||||
for (int t = tb; t < te; ++t) {
|
||||
float* qx = qidx_ + t * IQ * ID;
|
||||
@@ -454,12 +468,12 @@ bool Verifier::record_window(int T, cudaStream_t cs, std::string& err) {
|
||||
s, scores_ + (size_t) tb * max_blocks_, cs);
|
||||
qsa_block_topk(scores_ + (size_t) tb * max_blocks_, step_ + tb * kStepCount, n, max_blocks_, cap_, s,
|
||||
sel_ + (size_t) tb * cap_, cs);
|
||||
QsaAttnPools pools;
|
||||
pools.page_table = st.page_table;
|
||||
if (st.kv_int8) { pools.k_q = st.k_q; pools.v_q = st.v_q; pools.k_scale = st.k_scale; pools.v_scale = st.v_scale; }
|
||||
else { pools.k_pool = st.k_pool; pools.v_pool = st.v_pool; }
|
||||
// KV streaming: the n selections' blocks resident (device-side, inside the graph)
|
||||
qsa_kv_resolve(st, *g_, sel_ + (size_t) tb * cap_, step_ + tb * kStepCount, n, cap_, cs);
|
||||
const QsaAttnPools pools = qsa_attn_pools(st);
|
||||
qsa_decode_attn_batch(qcur_ + tb * NH * HD, pools, sel_ + (size_t) tb * cap_, step_ + tb * kStepCount, cap_,
|
||||
s, attn_scratch_ + (size_t) tb * attn_scratch_floats_, attn_ + tb * NH * HD, n, cs);
|
||||
if (st.kv_q4) fwht256_inplace_cuda(attn_ + tb * NH * HD, (int64_t) n * NH, cs); // back: H^-1 = H
|
||||
for (int t = tb; t < te; ++t) {
|
||||
if (native_qsa_enabled())
|
||||
native_qsa_gate_apply(attn_ + t * NH * HD, qfull_ + t * NH * 2 * HD, attn32_ + t * NH * HD,
|
||||
@@ -558,8 +572,12 @@ bool Verifier::record_window(int T, cudaStream_t cs, std::string& err) {
|
||||
mb.weights = w_ + t * K; mb.shared = shared_ + t * N;
|
||||
if (!moe_combine_parts(g, l, K, mb, parts_ + (size_t) t * K * N, bo_ + t * N, cs, err)) return false;
|
||||
}
|
||||
if (l == g.n_layers - 1)
|
||||
if (l == g.n_layers - 1) {
|
||||
for (int t = tb; t < te; ++t) gr_write(Rt(t), bo_ + t * N, inj2_ + t * HC, gs, Rt(t), cs);
|
||||
if (cvec().covers(l)) cvec_apply(Rt(tb), l, n, HC * N, nullptr, 0, nullptr, 0, false, cs);
|
||||
} else if (cvec().covers(l)) {
|
||||
cvec_apply(Rt(tb), l, n, HC * N, bo_ + tb * N, N, inj2_ + tb * HC, HC, true, cs);
|
||||
}
|
||||
return true;
|
||||
};
|
||||
|
||||
@@ -595,6 +613,9 @@ bool Verifier::record_window(int T, cudaStream_t cs, std::string& err) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// Greedy, the default, is recorded here as before (no extra launch or sync per window). A request that
|
||||
// samples or penalizes is sampled again host-side after the replay (run()) with its own parameters and a
|
||||
// fresh draw counter: a captured sampler would bake them in and replay the same draws forever.
|
||||
SamplerParams sp;
|
||||
sp.greedy = true;
|
||||
sp.temperature = 0.0f;
|
||||
@@ -794,6 +815,20 @@ bool Verifier::run(int T, const int32_t* tokens, int64_t pos0, PoolMultiFn pool,
|
||||
const cudaError_t se = cudaStreamSynchronize(cs_);
|
||||
if (se != cudaSuccess) { err = std::string("verify: ") + cudaGetErrorString(se); return false; }
|
||||
cudaStreamSynchronize(copy_); // no host function of this window may raise flag B in the next one
|
||||
// ---- a sampled or penalized request: the head's sampling again, host-side so its parameters are this call's
|
||||
// own (a captured kernel would replay the same draws forever). Row t's draw is Philox(seed, pos0 + t): tied to
|
||||
// the POSITION it samples, not to how the text was cut into windows, so a seed replays the same text whatever
|
||||
// the drafts were. Exact: a rejected row's draw is discarded, and no kept decision depends on a reused draw.
|
||||
const bool sampled = !sampling_.greedy && sampling_.temperature > 0.0f;
|
||||
if (sampled || hist_d_ != nullptr) {
|
||||
SamplerParams sp = sampling_;
|
||||
sp.counter = (uint64_t) pos0;
|
||||
sample_tokens(head_logits_, T, (int) n_vocab_, hist_d_, hist_len_, sp, m_out_, cs_);
|
||||
if (cudaStreamSynchronize(cs_) != cudaSuccess) { // m_out_ is the mapped h_out_: synced, it is readable
|
||||
err = "verify: the head sampling failed";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (int t = 0; t < T; ++t) out[t] = ((volatile int32_t*) h_out_)[t];
|
||||
VDBG("window done\n");
|
||||
++windows;
|
||||
|
||||
@@ -113,6 +113,11 @@ bool expert_layout_load(const std::string& pack_dir, int64_t n_layers, int64_t n
|
||||
L.gguf_off[(size_t) (3 * l)] = go;
|
||||
L.gguf_off[(size_t) (3 * l + 1)] = uo;
|
||||
L.gguf_off[(size_t) (3 * l + 2)] = dox;
|
||||
std::string file; // v3: the shard that holds this layer (a file name beside --native)
|
||||
if (ss >> file) {
|
||||
if (L.gguf_file.empty()) L.gguf_file.assign((size_t) n_layers, std::string());
|
||||
L.gguf_file[(size_t) l] = file;
|
||||
}
|
||||
}
|
||||
L.fmt[(size_t) l] = f;
|
||||
L.offset[(size_t) l] = off;
|
||||
|
||||
@@ -49,11 +49,12 @@ std::vector<int> physical_cores(bool skip_first) {
|
||||
#else
|
||||
cpu_set_t set;
|
||||
CPU_ZERO(&set);
|
||||
if (sched_getaffinity(0, sizeof set, &set) == 0)
|
||||
if (sched_getaffinity(0, sizeof set, &set) == 0) {
|
||||
for (int i = 0; i < CPU_SETSIZE; ++i)
|
||||
if (CPU_ISSET(i, &set)) cores.push_back(i);
|
||||
else
|
||||
} else {
|
||||
for (unsigned i = 0; i < std::thread::hardware_concurrency(); ++i) cores.push_back((int) i);
|
||||
}
|
||||
#endif
|
||||
if (skip_first && !cores.empty()) cores.erase(cores.begin());
|
||||
return cores;
|
||||
@@ -127,10 +128,23 @@ ExpertPool::ExpertPool(int n_workers, bool pin, bool host_works) : host_works_(h
|
||||
ExpertPool::~ExpertPool() {
|
||||
stop_.store(true, std::memory_order_release);
|
||||
// Bump the epoch so a PARKED worker notices the stop flag rather than sleeping through it.
|
||||
epoch_.fetch_add(1, std::memory_order_release);
|
||||
publish();
|
||||
for (auto& t : threads_) t.join();
|
||||
}
|
||||
|
||||
void ExpertPool::publish() {
|
||||
// Both sides are seq_cst, and that is the whole lost-wakeup argument: a worker going to sleep does
|
||||
// `sleepers_++` and then reads `epoch_`, the host does `epoch_++` and then reads `sleepers_`. In one total
|
||||
// order at least one of them sees the other's write - the worker sees the new epoch and does not sleep, or
|
||||
// the host sees the sleeper and notifies under the mutex the worker holds until it is inside `wait`.
|
||||
// On x86 the fetch_add is a locked xadd either way, so this costs the token path nothing.
|
||||
epoch_.fetch_add(1, std::memory_order_seq_cst);
|
||||
if (sleepers_.load(std::memory_order_seq_cst) != 0) {
|
||||
std::lock_guard<std::mutex> lk(sleep_mu_);
|
||||
sleep_cv_.notify_all();
|
||||
}
|
||||
}
|
||||
|
||||
void ExpertPool::worker(int id) {
|
||||
uint32_t seen = 0;
|
||||
// ARRIVE at the park before the first wait, so `parked_ == n_` is true from construction. Counting only
|
||||
@@ -147,9 +161,22 @@ void ExpertPool::worker(int id) {
|
||||
// - a locked read-modify-write, five workers against one cache line - so the workers spent their wait
|
||||
// invalidating each other's caches and the very line the host writes to publish work. The counter was
|
||||
// diagnostic and nothing branched on it. See the note on the atomics in pool.hpp.
|
||||
//
|
||||
// After `kSpinBeforeSleep` with no work the worker sleeps instead (issue #4). The clock is read once
|
||||
// every 1024 pauses, so the spin itself is unchanged.
|
||||
const auto parked_at = std::chrono::steady_clock::now();
|
||||
uint32_t spins = 0;
|
||||
while (epoch_.load(std::memory_order_acquire) == seen) {
|
||||
if (stop_.load(std::memory_order_relaxed)) return;
|
||||
_mm_pause();
|
||||
if ((++spins & 1023u) != 0) continue;
|
||||
if (std::chrono::steady_clock::now() - parked_at < kSpinBeforeSleep) continue;
|
||||
std::unique_lock<std::mutex> lk(sleep_mu_);
|
||||
sleepers_.fetch_add(1, std::memory_order_seq_cst);
|
||||
sleep_cv_.wait(lk, [&] {
|
||||
return epoch_.load(std::memory_order_seq_cst) != seen || stop_.load(std::memory_order_relaxed);
|
||||
});
|
||||
sleepers_.fetch_sub(1, std::memory_order_relaxed);
|
||||
}
|
||||
if (stop_.load(std::memory_order_acquire)) return;
|
||||
seen = epoch_.load(std::memory_order_relaxed);
|
||||
@@ -245,7 +272,7 @@ void ExpertPool::run_phase(int mode, int n_tasks) {
|
||||
njobs_ = n_tasks;
|
||||
head_.store(0, std::memory_order_relaxed);
|
||||
done_.store(0, std::memory_order_relaxed);
|
||||
epoch_.fetch_add(1, std::memory_order_release);
|
||||
publish();
|
||||
if (host_works_) drain(-1, host_scratch_);
|
||||
while (done_.load(std::memory_order_acquire) != (uint32_t) n_tasks) _mm_pause();
|
||||
while (parked_.load(std::memory_order_acquire) != (uint32_t) n_) _mm_pause();
|
||||
@@ -356,7 +383,7 @@ void ExpertPool::run(ExpertJob* jobs, int n) {
|
||||
mode_ = 0;
|
||||
head_.store(0, std::memory_order_relaxed);
|
||||
done_.store(0, std::memory_order_relaxed);
|
||||
epoch_.fetch_add(1, std::memory_order_release); // release: jobs_/njobs_ are visible before the bump
|
||||
publish(); // a release (seq_cst): jobs_/njobs_ are visible before the bump
|
||||
|
||||
// ---- **THE HOST DRAINS TOO (R2.2), INSTEAD OF SPINNING ON `done_`.**
|
||||
//
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
// src/kernels/cuda/cvec.cu - see include/strata/kernels/cvec.hpp.
|
||||
#include "strata/kernels/cvec.hpp"
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
namespace strata::kernels {
|
||||
namespace {
|
||||
|
||||
constexpr int THREADS = 256;
|
||||
constexpr int MAXK = 16; // n_embd up to 4096, held in registers between the dot and the update
|
||||
|
||||
Cvec g_cvec;
|
||||
int* g_on = nullptr;
|
||||
bool g_on_host = false;
|
||||
|
||||
// the fused hyper-connection read's gate (fused_gr.cu), so a write done here is bitwise the one it would have folded
|
||||
__device__ __forceinline__ float sigmoidf_(float x) { return 1.0f / (1.0f + __expf(-x)); }
|
||||
|
||||
// one block per (stream, token): the pending write, then h . v over the stream, then the update
|
||||
__global__ void cvec_kernel(float* __restrict__ R, const float* __restrict__ dir, const float* __restrict__ s_l,
|
||||
const int* __restrict__ on, int mode, int64_t layer, int n, int hc, int64_t r_ld,
|
||||
const float* __restrict__ bo, int64_t bo_ld, const float* __restrict__ inj,
|
||||
int64_t inj_ld, int write) {
|
||||
const int c = blockIdx.x;
|
||||
const int64_t t = blockIdx.y;
|
||||
float* r = R + t * r_ld + (int64_t) c * n;
|
||||
const float s = s_l[layer];
|
||||
const bool steer = *on != 0 && s != 0.0f; // uniform over the block
|
||||
if (!steer && !write) return;
|
||||
const float* v = dir + layer * n;
|
||||
const float w = write ? 2.0f * sigmoidf_(inj[t * inj_ld + c] / (float) hc) : 0.0f;
|
||||
const float* b = write ? bo + t * bo_ld : nullptr;
|
||||
float x[MAXK];
|
||||
float dot = 0.0f;
|
||||
#pragma unroll
|
||||
for (int k = 0; k < MAXK; ++k) {
|
||||
const int d = threadIdx.x + k * THREADS;
|
||||
if (d < n) {
|
||||
float xv = r[d];
|
||||
if (write) xv = fmaf(b[d], w, xv);
|
||||
x[k] = xv;
|
||||
if (steer && mode == 0) dot = fmaf(xv, v[d], dot);
|
||||
}
|
||||
}
|
||||
if (steer && mode == 0) {
|
||||
__shared__ float part[THREADS / 32];
|
||||
#pragma unroll
|
||||
for (int o = 16; o > 0; o >>= 1) dot += __shfl_xor_sync(0xffffffffu, dot, o);
|
||||
if ((threadIdx.x & 31) == 0) part[threadIdx.x >> 5] = dot;
|
||||
__syncthreads();
|
||||
if (threadIdx.x < 32) {
|
||||
float p = threadIdx.x < THREADS / 32 ? part[threadIdx.x] : 0.0f;
|
||||
#pragma unroll
|
||||
for (int o = 16; o > 0; o >>= 1) p += __shfl_xor_sync(0xffffffffu, p, o);
|
||||
if (threadIdx.x == 0) part[0] = p;
|
||||
}
|
||||
__syncthreads();
|
||||
dot = part[0] * s; // s (h . v)
|
||||
}
|
||||
#pragma unroll
|
||||
for (int k = 0; k < MAXK; ++k) {
|
||||
const int d = threadIdx.x + k * THREADS;
|
||||
if (d < n) {
|
||||
float xv = x[k];
|
||||
if (steer) xv = mode == 0 ? fmaf(-dot, v[d], xv) : xv + v[d];
|
||||
r[d] = xv;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
const Cvec& cvec() { return g_cvec; }
|
||||
|
||||
bool cvec_upload(const std::vector<float>& dir, const std::vector<float>& s, int mode, int first, int last,
|
||||
int64_t n_embd, int64_t hc, std::string& err) {
|
||||
if (n_embd < 1 || n_embd > (int64_t) THREADS * MAXK) { err = "control vector: unsupported n_embd"; return false; }
|
||||
if (s.empty() || dir.size() != s.size() * (size_t) n_embd) { err = "control vector: bad table sizes"; return false; }
|
||||
float* d_dir = nullptr;
|
||||
float* d_s = nullptr;
|
||||
int* d_on = nullptr;
|
||||
const int one = 1;
|
||||
if (cudaMalloc(&d_dir, dir.size() * sizeof(float)) != cudaSuccess ||
|
||||
cudaMalloc(&d_s, s.size() * sizeof(float)) != cudaSuccess || cudaMalloc(&d_on, sizeof(int)) != cudaSuccess ||
|
||||
cudaMemcpy(d_dir, dir.data(), dir.size() * sizeof(float), cudaMemcpyHostToDevice) != cudaSuccess ||
|
||||
cudaMemcpy(d_s, s.data(), s.size() * sizeof(float), cudaMemcpyHostToDevice) != cudaSuccess ||
|
||||
cudaMemcpy(d_on, &one, sizeof(int), cudaMemcpyHostToDevice) != cudaSuccess) {
|
||||
err = "control vector: device allocation failed";
|
||||
return false;
|
||||
}
|
||||
g_cvec.dir = d_dir;
|
||||
g_cvec.s = d_s;
|
||||
g_cvec.on = d_on;
|
||||
g_cvec.mode = mode;
|
||||
g_cvec.first = first;
|
||||
g_cvec.last = last;
|
||||
g_cvec.n_embd = n_embd;
|
||||
g_cvec.hc = hc;
|
||||
g_cvec.steered.assign(s.size(), false);
|
||||
for (size_t l = 0; l < s.size(); ++l) g_cvec.steered[l] = s[l] != 0.0f;
|
||||
g_on = d_on;
|
||||
g_on_host = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
void cvec_set_enabled(bool on) {
|
||||
if (g_on == nullptr || on == g_on_host) return;
|
||||
cudaDeviceSynchronize(); // nothing in flight may still read the flag
|
||||
const int v = on ? 1 : 0;
|
||||
cudaMemcpy(g_on, &v, sizeof(int), cudaMemcpyHostToDevice);
|
||||
g_on_host = on;
|
||||
}
|
||||
|
||||
bool cvec_enabled() { return g_on != nullptr && g_on_host; }
|
||||
|
||||
void cvec_apply(float* R, int64_t layer, int64_t T, int64_t r_ld, const float* bo, int64_t bo_ld, const float* inj,
|
||||
int64_t inj_ld, bool write, void* stream) {
|
||||
if (!g_cvec.loaded() || T < 1) return;
|
||||
const dim3 grid((unsigned) g_cvec.hc, (unsigned) T);
|
||||
cvec_kernel<<<grid, THREADS, 0, (cudaStream_t) stream>>>(R, g_cvec.dir, g_cvec.s, g_cvec.on, g_cvec.mode, layer,
|
||||
(int) g_cvec.n_embd, (int) g_cvec.hc, r_ld, bo, bo_ld,
|
||||
inj, inj_ld, write ? 1 : 0);
|
||||
if (cudaPeekAtLastError() != cudaSuccess) throw std::runtime_error("cvec_apply: launch failed");
|
||||
}
|
||||
|
||||
} // namespace strata::kernels
|
||||
@@ -268,6 +268,28 @@ __device__ __forceinline__ float vec_dot_iq4_nl_q8_1(const void* __restrict__ vb
|
||||
return d * sumi;
|
||||
}
|
||||
|
||||
// IQ4_XS: 256 values as 8 sub-blocks of 32 (6-bit scale each); one call covers one sub-block (iqs = 4 * sub-block),
|
||||
// and `bq8_1` is the super-block's first q8_1 block, so the call's activation is bq8_1[iqs / 4]. The GSQ-RCO IQ3_S
|
||||
// file keeps one layer's routed gate/up experts in this format.
|
||||
__device__ __forceinline__ float vec_dot_iq4_xs_q8_1(const void* __restrict__ vbq, const block_q8_1* __restrict__ bq8_1,
|
||||
const int& kbx, const int& iqs) {
|
||||
const block_iq4_xs* bq4 = (const block_iq4_xs*) vbq + kbx;
|
||||
int sumi = 0;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 4; ++j) {
|
||||
const int aux_q4 = get_int_b4(bq4->qs, iqs + j);
|
||||
const int2 v = get_int_from_table_16(aux_q4, kvalues_iq4nl);
|
||||
const int u0 = get_int_b4(bq8_1[iqs / 4].qs, j + 0);
|
||||
const int u1 = get_int_b4(bq8_1[iqs / 4].qs, j + 4);
|
||||
sumi = ggml_cuda_dp4a(v.x, u0, sumi);
|
||||
sumi = ggml_cuda_dp4a(v.y, u1, sumi);
|
||||
}
|
||||
const int ls = ((bq4->scales_l[iqs / 8] >> (iqs & 0x04)) & 0x0F) | (((bq4->scales_h >> (iqs / 2)) & 0x03) << 4);
|
||||
sumi *= ls - 32;
|
||||
const float d = __half2float(bq4->d) * __low2float(bq8_1[iqs / 4].ds);
|
||||
return d * sumi;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- the formats
|
||||
// qk = values per block, ipb = dot calls per block (qi / vdr), step = the iqs stride between calls.
|
||||
template<int TY> struct Fmt;
|
||||
@@ -281,6 +303,8 @@ template<> struct Fmt<20> { static constexpr int qk = 32, ipb = 2, step = 2;
|
||||
__device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_iq4_nl_q8_1(v, y, kbx, iqs); } };
|
||||
template<> struct Fmt<21> { static constexpr int qk = 256, ipb = 8, step = 2;
|
||||
__device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_iq3_s_q8_1(v, y, kbx, iqs); } };
|
||||
template<> struct Fmt<23> { static constexpr int qk = 256, ipb = 8, step = 4;
|
||||
__device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_iq4_xs_q8_1(v, y, kbx, iqs); } };
|
||||
template<> struct Fmt<22> { static constexpr int qk = 256, ipb = 8, step = 2;
|
||||
__device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_iq2_s_q8_1(v, y, kbx, iqs); } };
|
||||
template<> struct Fmt<29> { static constexpr int qk = 256, ipb = 8, step = 1;
|
||||
@@ -618,6 +642,7 @@ void iq_mmvq(int t, const void* w, const void* x_q8_1, float* y, int n_in, int n
|
||||
case 20: mmvq_kernel<20><<<grid, block, 0, s>>>(W, rb, X, y, n_in, n_out, ncols); break;
|
||||
case 21: mmvq_kernel<21><<<grid, block, 0, s>>>(W, rb, X, y, n_in, n_out, ncols); break;
|
||||
case 22: mmvq_kernel<22><<<grid, block, 0, s>>>(W, rb, X, y, n_in, n_out, ncols); break;
|
||||
case 23: mmvq_kernel<23><<<grid, block, 0, s>>>(W, rb, X, y, n_in, n_out, ncols); break;
|
||||
case 29: mmvq_kernel<29><<<grid, block, 0, s>>>(W, rb, X, y, n_in, n_out, ncols); break;
|
||||
case 42: mmvq_kernel<42><<<grid, block, 0, s>>>(W, rb, X, y, n_in, n_out, ncols); break;
|
||||
default: std::fprintf(stderr, "iq_mmvq: type %d is not supported\n", t); std::exit(1);
|
||||
@@ -700,6 +725,7 @@ void native_expert_grouped(const NativeExpertLayout& L, const unsigned long long
|
||||
case 18: native_gu_kernel<18><<<ggu, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_tok, X, L, gate, up); break;
|
||||
case 21: native_gu_kernel<21><<<ggu, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_tok, X, L, gate, up); break;
|
||||
case 22: native_gu_kernel<22><<<ggu, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_tok, X, L, gate, up); break;
|
||||
case 23: native_gu_kernel<23><<<ggu, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_tok, X, L, gate, up); break;
|
||||
case 29: native_gu_kernel<29><<<ggu, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_tok, X, L, gate, up); break;
|
||||
case 42: native_gu_kernel<42><<<ggu, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_tok, X, L, gate, up); break;
|
||||
default: std::fprintf(stderr, "native_expert_grouped: gate/up type %d\n", L.gu_type); std::exit(1);
|
||||
@@ -711,6 +737,7 @@ void native_expert_grouped(const NativeExpertLayout& L, const unsigned long long
|
||||
const dim3 gd((unsigned) ((L.n_embd + 7) / 8), (unsigned) cap_groups);
|
||||
switch (L.d_type) {
|
||||
case 20: native_down_kernel<20><<<gd, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_dst, hq, L, out); break;
|
||||
case 23: native_down_kernel<23><<<gd, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_dst, hq, L, out); break;
|
||||
case 42: native_down_kernel<42><<<gd, 256, 0, s>>>(grp_ptr, grp_start, n_groups, ent_dst, hq, L, out); break;
|
||||
default: std::fprintf(stderr, "native_expert_grouped: down type %d\n", L.d_type); std::exit(1);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,231 @@
|
||||
// src/kernels/cuda/kv_q4.cu - see include/strata/kernels/kv_q4.hpp. Q4_0 KV with Walsh-Hadamard rotation
|
||||
// (from PR #21 by code-martin; KV-streaming integration and the deterministic group maximum added on merge).
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
#include "strata/kernels/f16_bits.hpp"
|
||||
#include "strata/kernels/kv_stream.hpp"
|
||||
|
||||
#include <cuda_fp16.h>
|
||||
#include <cuda_runtime.h>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
|
||||
namespace strata::kernels {
|
||||
namespace {
|
||||
|
||||
void check(const char* what) {
|
||||
const cudaError_t e = cudaGetLastError();
|
||||
if (e != cudaSuccess) {
|
||||
std::fprintf(stderr, "kv_q4: %s: %s\n", what, cudaGetErrorString(e));
|
||||
std::exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// Fast Walsh-Hadamard Transform for N = 256: one warp per row, 8 values per lane in registers.
|
||||
// Orthonormal (scale 1/sqrt(256) = 1/16), so it is its own inverse.
|
||||
__global__ void fwht256_kernel(const float* __restrict__ src, float* __restrict__ dst, int64_t n_rows, float scale) {
|
||||
constexpr int warp_size = 32;
|
||||
constexpr int N = 256;
|
||||
constexpr int el_w = N / warp_size; // 8
|
||||
|
||||
const int64_t r = (int64_t) blockIdx.x * blockDim.y + threadIdx.y;
|
||||
if (r >= n_rows) return;
|
||||
|
||||
const float* row_src = src + r * N;
|
||||
float* row_dst = dst + r * N;
|
||||
|
||||
float reg[el_w];
|
||||
const int lane = threadIdx.x;
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i < el_w; ++i) reg[i] = row_src[i * warp_size + lane] * scale;
|
||||
|
||||
// the low 5 index bits live across lanes
|
||||
#pragma unroll
|
||||
for (int h = 1; h < warp_size; h *= 2) {
|
||||
#pragma unroll
|
||||
for (int j = 0; j < el_w; ++j) {
|
||||
const float val = reg[j];
|
||||
const float val2 = __shfl_xor_sync(0xffffffffu, val, h, warp_size);
|
||||
reg[j] = (lane & h) == 0 ? val + val2 : val2 - val;
|
||||
}
|
||||
}
|
||||
// the high 3 bits across each lane's registers
|
||||
#pragma unroll
|
||||
for (int h = warp_size; h < N; h *= 2) {
|
||||
const int step = h / warp_size;
|
||||
#pragma unroll
|
||||
for (int j = 0; j < el_w; j += 2 * step) {
|
||||
#pragma unroll
|
||||
for (int k = 0; k < step; ++k) {
|
||||
const float x = reg[j + k];
|
||||
const float y = reg[j + k + step];
|
||||
reg[j + k] = x + y;
|
||||
reg[j + k + step] = x - y;
|
||||
}
|
||||
}
|
||||
}
|
||||
#pragma unroll
|
||||
for (int i = 0; i < el_w; ++i) row_dst[i * warp_size + lane] = reg[i];
|
||||
}
|
||||
|
||||
// One 32-value group in one warp (lane = element), ggml's q4_0: d = (the value of largest |x|) / -8,
|
||||
// q = clamp(trunc(x / d + 8.5), 0, 15). Returns the scale bits; `byte` is lane t's packed byte for t < 16
|
||||
// (element t in the low nibble, t + 16 in the high one). Ties in |x| resolve to the larger value in EVERY lane,
|
||||
// so all lanes agree on d (a plain `a > amax` could leave lanes with opposite signs and one block two scales).
|
||||
__device__ __forceinline__ uint16_t q4_group(float x, int lane, uint8_t& byte) {
|
||||
float amax = fabsf(x), mval = x;
|
||||
#pragma unroll
|
||||
for (int o = 16; o > 0; o >>= 1) {
|
||||
const float a = __shfl_xor_sync(0xffffffffu, amax, o);
|
||||
const float v = __shfl_xor_sync(0xffffffffu, mval, o);
|
||||
if (a > amax || (a == amax && v > mval)) { amax = a; mval = v; }
|
||||
}
|
||||
const float d = mval / -8.0f;
|
||||
const float id = d != 0.0f ? 1.0f / d : 0.0f;
|
||||
int q = __float2int_rz(x * id + 8.5f);
|
||||
const uint8_t qc = (uint8_t) (q < 0 ? 0 : (q > 15 ? 15 : q));
|
||||
const uint8_t qhi = __shfl_down_sync(0xffffffffu, qc, 16);
|
||||
byte = (uint8_t) (qc | (qhi << 4));
|
||||
(void) lane;
|
||||
return f16_from_f32(d);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void q4_store(uint8_t* pool, long long row, int b, int lane, uint16_t d, uint8_t byte) {
|
||||
block_q4_0* blk = reinterpret_cast<block_q4_0*>(pool + row * (long long) sizeof(block_q4_0) * 8) + b;
|
||||
if (lane == 0) blk->d = d;
|
||||
if (lane < 16) blk->qs[lane] = byte;
|
||||
}
|
||||
|
||||
// One block = one 32-value group of one KV head of K (blockIdx.z = 0) or V (1); 32 threads. KV streaming: the VRAM
|
||||
// page only if the block is resident (table >= 0), the host copy always (identity layout) when there is one.
|
||||
__global__ void kv_append_q4_kernel(uint8_t* __restrict__ k_q4, uint8_t* __restrict__ v_q4,
|
||||
const int32_t* __restrict__ table, const int32_t* __restrict__ step,
|
||||
const float* __restrict__ kcur, const float* __restrict__ vcur,
|
||||
int kv_heads, int head_dim, int page_size, KvHostPools host) {
|
||||
const long long pos = (long long) __ldg(step + kStepPos);
|
||||
const int h = blockIdx.x, b = blockIdx.y, t = threadIdx.x;
|
||||
const bool is_v = blockIdx.z == 1;
|
||||
const float x = (is_v ? vcur : kcur)[h * head_dim + b * QK4_0 + t];
|
||||
uint8_t byte;
|
||||
const uint16_t d = q4_group(x, t, byte);
|
||||
const long long page = (long long) table[pos / page_size];
|
||||
if (page >= 0) q4_store(is_v ? v_q4 : k_q4, (page * kv_heads + h) * page_size + (pos % page_size), b, t, d, byte);
|
||||
if (host.k_q4 != nullptr)
|
||||
q4_store(is_v ? host.v_q4 : host.k_q4, ((pos / page_size) * kv_heads + h) * page_size + (pos % page_size), b, t,
|
||||
d, byte);
|
||||
}
|
||||
|
||||
// The prompt path: grid (T, kv_heads, groups), K then V; also into the staging pool (identity layout) when given.
|
||||
__global__ void kv_append_q4_batch_kernel(uint8_t* __restrict__ k_q4, uint8_t* __restrict__ v_q4,
|
||||
const int32_t* __restrict__ table, int64_t pos0,
|
||||
const float* __restrict__ K, const float* __restrict__ V,
|
||||
int kv_heads, int head_dim, int page_size, int is_v_grid, KvHostPools host,
|
||||
KvHostPools stage) {
|
||||
const long long t = blockIdx.x;
|
||||
const long long pos = pos0 + t;
|
||||
const int h = blockIdx.y, b = blockIdx.z, th = threadIdx.x;
|
||||
const bool is_v = is_v_grid != 0;
|
||||
const float x = (is_v ? V : K)[t * (kv_heads * head_dim) + h * head_dim + b * QK4_0 + th];
|
||||
uint8_t byte;
|
||||
const uint16_t d = q4_group(x, th, byte);
|
||||
const long long page = (long long) table[pos / page_size];
|
||||
const long long row_id = ((pos / page_size) * kv_heads + h) * page_size + (pos % page_size);
|
||||
if (page >= 0) q4_store(is_v ? v_q4 : k_q4, (page * kv_heads + h) * page_size + (pos % page_size), b, th, d, byte);
|
||||
if (host.k_q4 != nullptr) q4_store(is_v ? host.v_q4 : host.k_q4, row_id, b, th, d, byte);
|
||||
if (stage.k_q4 != nullptr) q4_store(is_v ? stage.v_q4 : stage.k_q4, row_id, b, th, d, byte);
|
||||
}
|
||||
|
||||
// Gather step[kStepWidth] cells into FP16 scratch (the non-fused attention paths)
|
||||
__global__ void kv_gather_q4_kernel(const uint8_t* __restrict__ k_q4, const uint8_t* __restrict__ v_q4,
|
||||
const int32_t* __restrict__ table, const int32_t* __restrict__ ids,
|
||||
const int32_t* __restrict__ step, int kv_heads, int head_dim, int page_size,
|
||||
uint16_t* __restrict__ k_scratch, uint16_t* __restrict__ v_scratch) {
|
||||
const long long n_ids = (long long) __ldg(step + kStepWidth);
|
||||
const int blocks_per_head = head_dim / QK4_0; // 8
|
||||
const int bytes_per_head = blocks_per_head * sizeof(block_q4_0); // 144
|
||||
const long long total_blocks = n_ids * kv_heads * blocks_per_head;
|
||||
|
||||
const long long blk_idx = (long long) blockIdx.x * blockDim.y + threadIdx.y;
|
||||
if (blk_idx >= total_blocks) return;
|
||||
|
||||
const int t = threadIdx.x;
|
||||
const long long id = blk_idx / (kv_heads * blocks_per_head);
|
||||
const int rem = (int) (blk_idx % (kv_heads * blocks_per_head));
|
||||
const int h = rem / blocks_per_head;
|
||||
const int b = rem % blocks_per_head;
|
||||
|
||||
const int cell = ids[id];
|
||||
const long long page = (long long) table[cell / page_size];
|
||||
const long long row = (page * kv_heads + h) * page_size + (cell % page_size);
|
||||
|
||||
const block_q4_0* k_blk = reinterpret_cast<const block_q4_0*>(k_q4 + row * bytes_per_head) + b;
|
||||
const block_q4_0* v_blk = reinterpret_cast<const block_q4_0*>(v_q4 + row * bytes_per_head) + b;
|
||||
const float kd = f32_from_f16(k_blk->d);
|
||||
const float vd = f32_from_f16(v_blk->d);
|
||||
const int j = t < 16 ? t : (t - 16);
|
||||
const uint8_t k_byte = k_blk->qs[j];
|
||||
const uint8_t v_byte = v_blk->qs[j];
|
||||
const int kq = (t < 16) ? ((k_byte & 0x0F) - 8) : ((k_byte >> 4) - 8);
|
||||
const int vq = (t < 16) ? ((v_byte & 0x0F) - 8) : ((v_byte >> 4) - 8);
|
||||
const long long dst_offset = ((id * kv_heads + h) * head_dim) + (b * QK4_0 + t);
|
||||
k_scratch[dst_offset] = f16_from_f32((float) kq * kd);
|
||||
v_scratch[dst_offset] = f16_from_f32((float) vq * vd);
|
||||
}
|
||||
|
||||
void need_256(const QsaShapes& s, const char* what) {
|
||||
if (s.head_dim != 256) {
|
||||
std::fprintf(stderr, "%s: head_dim must be 256 (the Hadamard transform's size)\n", what);
|
||||
std::exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void fwht256_cuda(const float* src, float* dst, int64_t n_rows, void* stream) {
|
||||
if (n_rows <= 0) return;
|
||||
const int rows_per_block = 4;
|
||||
const int64_t num_blocks = (n_rows + rows_per_block - 1) / rows_per_block;
|
||||
fwht256_kernel<<<dim3((unsigned) num_blocks), dim3(32, rows_per_block), 0, (cudaStream_t) stream>>>(
|
||||
src, dst, n_rows, 1.0f / 16.0f);
|
||||
check("fwht256 launch");
|
||||
}
|
||||
|
||||
void kv_append_q4_step(uint8_t* k_q4, uint8_t* v_q4, const int32_t* page_table, const int32_t* step,
|
||||
const float* kcur, const float* vcur, const QsaShapes& s, void* stream,
|
||||
const KvHostPools* host) {
|
||||
need_256(s, "kv_append_q4");
|
||||
const dim3 grid((unsigned) s.n_head_kv, (unsigned) (s.head_dim / QK4_0), 2);
|
||||
kv_append_q4_kernel<<<grid, 32, 0, (cudaStream_t) stream>>>(
|
||||
k_q4, v_q4, page_table, step, kcur, vcur, (int) s.n_head_kv, (int) s.head_dim, (int) s.page_size,
|
||||
host ? *host : KvHostPools{});
|
||||
check("kv_append_q4 launch");
|
||||
}
|
||||
|
||||
void kv_append_q4(uint8_t* k_q4, uint8_t* v_q4, const int32_t* page_table, int64_t pos0, int64_t T, const float* K,
|
||||
const float* V, const QsaShapes& s, void* stream, const KvHostPools* host, const KvHostPools* stage) {
|
||||
if (T <= 0) return;
|
||||
need_256(s, "kv_append_q4");
|
||||
const dim3 grid((unsigned) T, (unsigned) s.n_head_kv, (unsigned) (s.head_dim / QK4_0));
|
||||
cudaStream_t cs = (cudaStream_t) stream;
|
||||
const KvHostPools h = host ? *host : KvHostPools{}, st = stage ? *stage : KvHostPools{};
|
||||
for (int is_v = 0; is_v < 2; ++is_v)
|
||||
kv_append_q4_batch_kernel<<<grid, 32, 0, cs>>>(k_q4, v_q4, page_table, pos0, K, V, (int) s.n_head_kv,
|
||||
(int) s.head_dim, (int) s.page_size, is_v, h, st);
|
||||
check("kv_append_q4 batch launch");
|
||||
}
|
||||
|
||||
void kv_gather_q4_step(const uint8_t* k_q4, const uint8_t* v_q4, const int32_t* page_table, const int32_t* ids,
|
||||
const int32_t* step, int64_t max_ids, const QsaShapes& s, uint16_t* k_scratch,
|
||||
uint16_t* v_scratch, void* stream) {
|
||||
if (max_ids <= 0) return;
|
||||
const int blocks_per_head = (int) (s.head_dim / QK4_0);
|
||||
const int64_t total_blocks = max_ids * s.n_head_kv * blocks_per_head;
|
||||
const int rows_per_block = 4;
|
||||
const unsigned num_blocks = (unsigned) ((total_blocks + rows_per_block - 1) / rows_per_block);
|
||||
kv_gather_q4_kernel<<<dim3(num_blocks), dim3(32, rows_per_block), 0, (cudaStream_t) stream>>>(
|
||||
k_q4, v_q4, page_table, ids, step, (int) s.n_head_kv, (int) s.head_dim, (int) s.page_size, k_scratch,
|
||||
v_scratch);
|
||||
check("kv_gather_q4 launch");
|
||||
}
|
||||
|
||||
} // namespace strata::kernels
|
||||
@@ -31,7 +31,7 @@ __global__ void kv_append_q8_kernel(int8_t* __restrict__ k_q, int8_t* __restrict
|
||||
uint16_t* __restrict__ k_scale, uint16_t* __restrict__ v_scale,
|
||||
const int32_t* __restrict__ table, const int32_t* __restrict__ step,
|
||||
const float* __restrict__ kcur, const float* __restrict__ vcur, int kv_heads,
|
||||
int head_dim, int page_size) {
|
||||
int head_dim, int page_size, KvHostPools host) {
|
||||
const long long pos = (long long) __ldg(step + kStepPos);
|
||||
const int h = blockIdx.x, g = blockIdx.y, t = threadIdx.x;
|
||||
const bool is_v = blockIdx.z == 1;
|
||||
@@ -51,10 +51,18 @@ __global__ void kv_append_q8_kernel(int8_t* __restrict__ k_q, int8_t* __restrict
|
||||
q = __float2int_rn(x / sf);
|
||||
q = q < -127 ? -127 : (q > 127 ? 127 : q);
|
||||
}
|
||||
// KV streaming: the host copy (identity layout) always, the VRAM page only if the block is resident
|
||||
const long long page = (long long) table[pos / page_size];
|
||||
const long long row = (page * kv_heads + h) * page_size + (pos % page_size);
|
||||
(is_v ? v_q : k_q)[row * head_dim + g * KV_Q8_GROUP + t] = (int8_t) q;
|
||||
if (t == 0) (is_v ? v_scale : k_scale)[row * groups + g] = sbits;
|
||||
if (page >= 0) {
|
||||
const long long row = (page * kv_heads + h) * page_size + (pos % page_size);
|
||||
(is_v ? v_q : k_q)[row * head_dim + g * KV_Q8_GROUP + t] = (int8_t) q;
|
||||
if (t == 0) (is_v ? v_scale : k_scale)[row * groups + g] = sbits;
|
||||
}
|
||||
if (host.k_q != nullptr) {
|
||||
const long long row = ((pos / page_size) * kv_heads + h) * page_size + (pos % page_size);
|
||||
(is_v ? host.v_q : host.k_q)[row * head_dim + g * KV_Q8_GROUP + t] = (int8_t) q;
|
||||
if (t == 0) (is_v ? host.v_scale : host.k_scale)[row * groups + g] = sbits;
|
||||
}
|
||||
}
|
||||
|
||||
// One thread = 4 consecutive values of one cell and head (as the FP16 gather does with uint2).
|
||||
@@ -93,12 +101,13 @@ __global__ void kv_gather_q8_kernel(const int8_t* __restrict__ k_q, const int8_t
|
||||
} // namespace
|
||||
|
||||
void kv_append_q8_step(int8_t* k_q, int8_t* v_q, uint16_t* k_scale, uint16_t* v_scale, const int32_t* page_table,
|
||||
const int32_t* step, const float* kcur, const float* vcur, const QsaShapes& s, void* stream) {
|
||||
const int32_t* step, const float* kcur, const float* vcur, const QsaShapes& s, void* stream,
|
||||
const KvHostPools* host) {
|
||||
validate(s, "kv_append_q8");
|
||||
const dim3 grid((unsigned) s.n_head_kv, (unsigned) (s.head_dim / KV_Q8_GROUP), 2);
|
||||
kv_append_q8_kernel<<<grid, KV_Q8_GROUP, 0, (cudaStream_t) stream>>>(
|
||||
k_q, v_q, k_scale, v_scale, page_table, step, kcur, vcur, (int) s.n_head_kv, (int) s.head_dim,
|
||||
(int) s.page_size);
|
||||
(int) s.page_size, host ? *host : KvHostPools{});
|
||||
check("kv_append_q8 launch");
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,258 @@
|
||||
// src/kernels/cuda/kv_stream.cu - see include/strata/kernels/kv_stream.hpp.
|
||||
#include "strata/kernels/kv_stream.hpp"
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
#include "strata/kernels/kv_q8.hpp"
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
|
||||
namespace strata::kernels {
|
||||
namespace {
|
||||
|
||||
void check(const char* what) {
|
||||
const cudaError_t e = cudaGetLastError();
|
||||
if (e != cudaSuccess) {
|
||||
std::fprintf(stderr, "kv_stream: %s: %s\n", what, cudaGetErrorString(e));
|
||||
std::exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
constexpr int RT = 1024; // the resolve block
|
||||
|
||||
// The per-block byte runs of the (up to four) pool arrays: block b of array i is bytes [b * len, (b + 1) * len).
|
||||
struct Runs {
|
||||
const uint8_t* src[4];
|
||||
uint8_t* dst[4];
|
||||
int len[4];
|
||||
int n;
|
||||
};
|
||||
|
||||
Runs runs_of(const QsaAttnPools& slots, const KvHostPools& host, int fmt, const QsaShapes& s) {
|
||||
const int rows = (int) (s.n_head_kv * s.page_size);
|
||||
Runs r{};
|
||||
if (fmt == kKvQ4) {
|
||||
const int bytes = rows * (int) kv_q4_bytes_per_head((int) s.head_dim);
|
||||
r.src[0] = (const uint8_t*) host.k_q4; r.dst[0] = (uint8_t*) slots.k_q4; r.len[0] = bytes;
|
||||
r.src[1] = (const uint8_t*) host.v_q4; r.dst[1] = (uint8_t*) slots.v_q4; r.len[1] = bytes;
|
||||
r.n = 2;
|
||||
} else if (fmt == kKvInt8) {
|
||||
const int codes = rows * (int) s.head_dim, scales = rows * (int) (s.head_dim / KV_Q8_GROUP) * 2;
|
||||
r.src[0] = (const uint8_t*) host.k_q; r.dst[0] = (uint8_t*) slots.k_q; r.len[0] = codes;
|
||||
r.src[1] = (const uint8_t*) host.v_q; r.dst[1] = (uint8_t*) slots.v_q; r.len[1] = codes;
|
||||
r.src[2] = (const uint8_t*) host.k_scale; r.dst[2] = (uint8_t*) slots.k_scale; r.len[2] = scales;
|
||||
r.src[3] = (const uint8_t*) host.v_scale; r.dst[3] = (uint8_t*) slots.v_scale; r.len[3] = scales;
|
||||
r.n = 4;
|
||||
} else {
|
||||
const int bytes = rows * (int) s.head_dim * 2;
|
||||
r.src[0] = (const uint8_t*) host.k_pool; r.dst[0] = (uint8_t*) slots.k_pool; r.len[0] = bytes;
|
||||
r.src[1] = (const uint8_t*) host.v_pool; r.dst[1] = (uint8_t*) slots.v_pool; r.len[1] = bytes;
|
||||
r.n = 2;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
// Block-wide exclusive prefix sum of one int per thread (RT threads); `total` is the sum over the block.
|
||||
__device__ int block_scan(int v, int* warp_sums, int& total) {
|
||||
const int lane = threadIdx.x & 31, w = threadIdx.x >> 5;
|
||||
int x = v;
|
||||
for (int o = 1; o < 32; o <<= 1) {
|
||||
const int y = __shfl_up_sync(0xffffffffu, x, o);
|
||||
if (lane >= o) x += y;
|
||||
}
|
||||
if (lane == 31) warp_sums[w] = x;
|
||||
__syncthreads();
|
||||
if (w == 0) {
|
||||
int t = warp_sums[lane];
|
||||
for (int o = 1; o < 32; o <<= 1) {
|
||||
const int y = __shfl_up_sync(0xffffffffu, t, o);
|
||||
if (lane >= o) t += y;
|
||||
}
|
||||
warp_sums[lane] = t;
|
||||
}
|
||||
__syncthreads();
|
||||
total = warp_sums[31];
|
||||
const int excl = x - v + (w > 0 ? warp_sums[w - 1] : 0);
|
||||
__syncthreads();
|
||||
return excl;
|
||||
}
|
||||
|
||||
__global__ void __launch_bounds__(RT) resolve_kernel(KvStreamMap m, const int32_t* __restrict__ ids,
|
||||
const int32_t* __restrict__ steps, int n_q, int cap, int page_size) {
|
||||
__shared__ int s_nmiss, s_lookups, s_cut;
|
||||
__shared__ int warp_sums[32];
|
||||
const int epoch = m.ctl[0] + 1;
|
||||
if (threadIdx.x == 0) { s_nmiss = 0; s_lookups = 0; }
|
||||
__syncthreads();
|
||||
// 1. hits take this epoch and their reference bit; a missing block is claimed exactly once (-1 -> -2)
|
||||
int lookups = 0;
|
||||
for (int q = 0; q < n_q; ++q) {
|
||||
const int width = steps[q * kStepCount + kStepWidth];
|
||||
const int32_t* qi = ids + (long long) q * cap;
|
||||
for (int i = threadIdx.x; i < width; i += RT) {
|
||||
const int b = qi[i] / page_size;
|
||||
if (i > 0 && qi[i - 1] / page_size == b) continue; // ids are ascending: one lookup per block
|
||||
++lookups;
|
||||
const int sl = m.page_table[b];
|
||||
if (sl >= 0) {
|
||||
m.slot_stamp[sl] = epoch;
|
||||
m.slot_ref[sl] = 1;
|
||||
} else if (sl == -1 && atomicCAS(&m.page_table[b], -1, -2) == -1) {
|
||||
m.miss_block[atomicAdd(&s_nmiss, 1)] = b;
|
||||
}
|
||||
}
|
||||
}
|
||||
atomicAdd(&s_lookups, lookups);
|
||||
__syncthreads();
|
||||
// 2. one victim per miss: a clock sweep from the hand. A slot this call uses (stamp == epoch) is never taken;
|
||||
// a referenced one loses its bit as the hand passes it and is taken on the next pass.
|
||||
const int need = s_nmiss, n = (int) m.n_slots;
|
||||
int hand = m.ctl[1], got = 0;
|
||||
for (int scanned = 0; got < need && scanned < 3 * n; scanned += RT) {
|
||||
const int j = (int) (((long long) hand + threadIdx.x) % n);
|
||||
const bool mine = m.slot_stamp[j] == epoch;
|
||||
const bool cand = !mine && (m.slot_block[j] < 0 || m.slot_ref[j] == 0);
|
||||
int total = 0;
|
||||
const int rank = block_scan(cand ? 1 : 0, warp_sums, total);
|
||||
const int want = need - got;
|
||||
if (threadIdx.x == 0) s_cut = RT;
|
||||
__syncthreads();
|
||||
if (cand && rank == want - 1) s_cut = threadIdx.x + 1; // the hand stops just past the last slot taken
|
||||
__syncthreads();
|
||||
const int cut = s_cut;
|
||||
if (cand && rank < want) {
|
||||
m.miss_slot[got + rank] = j;
|
||||
m.slot_stamp[j] = epoch; // taken: a sweep that wraps around must not take it twice
|
||||
} else if (threadIdx.x < cut && !mine) {
|
||||
m.slot_ref[j] = 0;
|
||||
}
|
||||
got += total < want ? total : want;
|
||||
hand = (int) (((long long) hand + cut) % n);
|
||||
__syncthreads();
|
||||
}
|
||||
// 3. re-point the table; the copy kernel fills the slots
|
||||
const int placed = got < need ? got : need;
|
||||
for (int k = threadIdx.x; k < need; k += RT) {
|
||||
const int b = m.miss_block[k];
|
||||
if (k >= placed) { m.page_table[b] = -1; continue; } // overflow: never happens with a legal n_slots
|
||||
const int sl = m.miss_slot[k];
|
||||
const int old = m.slot_block[sl];
|
||||
if (old >= 0) m.page_table[old] = -1;
|
||||
m.slot_block[sl] = b;
|
||||
m.slot_stamp[sl] = epoch;
|
||||
m.slot_ref[sl] = 1;
|
||||
m.page_table[b] = sl;
|
||||
}
|
||||
if (threadIdx.x == 0) {
|
||||
m.ctl[0] = epoch;
|
||||
m.ctl[1] = hand;
|
||||
m.ctl[2] = placed;
|
||||
if (placed < need) m.ctl[3] = 1;
|
||||
unsigned long long* c = reinterpret_cast<unsigned long long*>(m.ctl + 4);
|
||||
c[0] += (unsigned long long) placed;
|
||||
c[1] += (unsigned long long) s_lookups;
|
||||
c[2] += 1ull;
|
||||
}
|
||||
}
|
||||
|
||||
// One block per missed block (grid-stride): copy its runs from the host copy into its slot, 16 B per thread.
|
||||
__global__ void copy_kernel(KvStreamMap m, Runs r) {
|
||||
const int need = m.ctl[2];
|
||||
for (int k = blockIdx.x; k < need; k += gridDim.x) {
|
||||
const long long b = m.miss_block[k], sl = m.miss_slot[k];
|
||||
for (int a = 0; a < r.n; ++a) {
|
||||
const uint4* src = reinterpret_cast<const uint4*>(r.src[a] + b * r.len[a]);
|
||||
uint4* dst = reinterpret_cast<uint4*>(r.dst[a] + sl * r.len[a]);
|
||||
for (int i = threadIdx.x; i < r.len[a] / 16; i += blockDim.x) dst[i] = src[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__global__ void reset_kernel(KvStreamMap m) {
|
||||
const long long i0 = (long long) blockIdx.x * blockDim.x + threadIdx.x, st = (long long) gridDim.x * blockDim.x;
|
||||
for (long long i = i0; i < m.n_blocks; i += st) m.page_table[i] = -1;
|
||||
for (long long i = i0; i < m.n_slots; i += st) {
|
||||
m.slot_block[i] = -1;
|
||||
m.slot_stamp[i] = -1;
|
||||
m.slot_ref[i] = 0;
|
||||
}
|
||||
if (i0 < kKvCtlInts) m.ctl[i0] = 0;
|
||||
}
|
||||
|
||||
__global__ void ring_kernel(int32_t* table, long long n_blocks, long long n_slots) {
|
||||
for (long long i = (long long) blockIdx.x * blockDim.x + threadIdx.x; i < n_blocks;
|
||||
i += (long long) gridDim.x * blockDim.x)
|
||||
table[i] = (int32_t) (i % n_slots);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
uint64_t kv_block_bytes(const QsaShapes& s, int fmt) {
|
||||
const uint64_t rows = (uint64_t) (s.n_head_kv * s.page_size);
|
||||
if (fmt == kKvQ4) return rows * kv_q4_bytes_per_head((int) s.head_dim) * 2;
|
||||
return fmt == kKvInt8 ? rows * (uint64_t) s.head_dim * 2 + rows * (uint64_t) (s.head_dim / KV_Q8_GROUP) * 2 * 2
|
||||
: rows * (uint64_t) s.head_dim * 2 * 2;
|
||||
}
|
||||
|
||||
void kv_stream_reset(const KvStreamMap& m, void* stream) {
|
||||
reset_kernel<<<128, 256, 0, (cudaStream_t) stream>>>(m);
|
||||
check("reset");
|
||||
}
|
||||
|
||||
void kv_stream_resolve(const KvStreamMap& m, const QsaAttnPools& slots, const KvHostPools& host, int fmt,
|
||||
const int32_t* ids, const int32_t* steps, int64_t n_q, int64_t cap, const QsaShapes& s,
|
||||
void* stream) {
|
||||
if (n_q <= 0) return;
|
||||
if (s.n_head_kv * s.page_size * (s.head_dim / KV_Q8_GROUP) * 2 % 16 != 0) {
|
||||
std::fprintf(stderr, "kv_stream: a block's scale run must be a multiple of 16 bytes\n");
|
||||
std::exit(1);
|
||||
}
|
||||
resolve_kernel<<<1, RT, 0, (cudaStream_t) stream>>>(m, ids, steps, (int) n_q, (int) cap, (int) s.page_size);
|
||||
check("resolve");
|
||||
copy_kernel<<<96, 128, 0, (cudaStream_t) stream>>>(m, runs_of(slots, host, fmt, s));
|
||||
check("copy");
|
||||
}
|
||||
|
||||
void kv_ring_table(int32_t* page_table, int64_t n_blocks, int64_t n_slots, void* stream) {
|
||||
ring_kernel<<<64, 256, 0, (cudaStream_t) stream>>>(page_table, n_blocks, n_slots);
|
||||
check("ring table");
|
||||
}
|
||||
|
||||
void kv_ring_restore(const QsaAttnPools& slots, const KvHostPools& host, int fmt, int64_t b0, int64_t b1,
|
||||
int64_t n_slots, const QsaShapes& s, void* stream) {
|
||||
const Runs r = runs_of(slots, host, fmt, s);
|
||||
for (int64_t b = b0; b < b1;) {
|
||||
const int64_t sl = b % n_slots, run = std::min<int64_t>(b1 - b, n_slots - sl); // up to the ring's end
|
||||
for (int a = 0; a < r.n; ++a)
|
||||
if (cudaMemcpyAsync(r.dst[a] + sl * r.len[a], r.src[a] + b * r.len[a], (size_t) (run * r.len[a]),
|
||||
cudaMemcpyDefault, (cudaStream_t) stream) != cudaSuccess)
|
||||
check("ring restore");
|
||||
b += run;
|
||||
}
|
||||
}
|
||||
|
||||
void kv_stage_from_host(const QsaAttnPools& stage, const KvHostPools& host, int fmt, int64_t n_blocks,
|
||||
const QsaShapes& s, void* stream) {
|
||||
if (n_blocks <= 0) return;
|
||||
const Runs r = runs_of(stage, host, fmt, s);
|
||||
for (int a = 0; a < r.n; ++a)
|
||||
if (cudaMemcpyAsync(r.dst[a], r.src[a], (size_t) (n_blocks * r.len[a]), cudaMemcpyDefault,
|
||||
(cudaStream_t) stream) != cudaSuccess)
|
||||
check("stage");
|
||||
}
|
||||
|
||||
KvStreamCounters kv_stream_counters(const KvStreamMap& m) {
|
||||
int32_t c[kKvCtlInts] = {};
|
||||
KvStreamCounters r;
|
||||
if (m.ctl == nullptr || cudaMemcpy(c, m.ctl, sizeof(c), cudaMemcpyDeviceToHost) != cudaSuccess) return r;
|
||||
const unsigned long long* u = reinterpret_cast<const unsigned long long*>(c + 4);
|
||||
r.misses = u[0];
|
||||
r.lookups = u[1];
|
||||
r.calls = u[2];
|
||||
r.overflow = c[3] != 0;
|
||||
return r;
|
||||
}
|
||||
|
||||
} // namespace strata::kernels
|
||||
+17
-7
@@ -43,6 +43,7 @@
|
||||
#include "strata/kernels/qsa.hpp"
|
||||
|
||||
#include "strata/kernels/f16_bits.hpp"
|
||||
#include "strata/kernels/kv_stream.hpp"
|
||||
#include "strata/kernels/rope.hpp"
|
||||
#include "strata/kernels/mrope.hpp"
|
||||
|
||||
@@ -120,16 +121,24 @@ __device__ __forceinline__ float h2f(uint16_t bits) { return f32_from_f16(bits);
|
||||
__global__ void kv_append_kernel(uint16_t* __restrict__ k_pool, uint16_t* __restrict__ v_pool,
|
||||
const int32_t* __restrict__ table, const int32_t* __restrict__ step,
|
||||
const float* __restrict__ kcur, const float* __restrict__ vcur, int kv_heads,
|
||||
int head_dim, int page_size) {
|
||||
int head_dim, int page_size, KvHostPools host) {
|
||||
const long long pos = (long long) __ldg(step + kStepPos);
|
||||
const int i = blockIdx.x * blockDim.x + threadIdx.x;
|
||||
if (i >= kv_heads * head_dim) return;
|
||||
const int h = i / head_dim, d = i - h * head_dim;
|
||||
// `[page][kv_head][page_size][head_dim]`: one head's consecutive cells are contiguous inside a page
|
||||
// `[page][kv_head][page_size][head_dim]`: one head's consecutive cells are contiguous inside a page.
|
||||
// KV streaming: the host copy (identity layout) always, the VRAM page only if the block is resident.
|
||||
const long long page = (long long) table[pos / page_size];
|
||||
const long long row = (page * kv_heads + h) * page_size + (pos % page_size);
|
||||
k_pool[row * head_dim + d] = f16_from_f32(kcur[i]);
|
||||
v_pool[row * head_dim + d] = f16_from_f32(vcur[i]);
|
||||
if (page >= 0) {
|
||||
const long long row = (page * kv_heads + h) * page_size + (pos % page_size);
|
||||
k_pool[row * head_dim + d] = f16_from_f32(kcur[i]);
|
||||
v_pool[row * head_dim + d] = f16_from_f32(vcur[i]);
|
||||
}
|
||||
if (host.k_pool != nullptr) {
|
||||
const long long row = ((pos / page_size) * kv_heads + h) * page_size + (pos % page_size);
|
||||
host.k_pool[row * head_dim + d] = f16_from_f32(kcur[i]);
|
||||
host.v_pool[row * head_dim + d] = f16_from_f32(vcur[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// ================= 2. indexer_key_append =================
|
||||
@@ -575,13 +584,14 @@ const int32_t* step_upload_width(int64_t width, const QsaShapes& s) {
|
||||
// buffer and forward this token's counts as the capacities.
|
||||
|
||||
void kv_append_step(uint16_t* k_pool, uint16_t* v_pool, const int32_t* page_table, const int32_t* step,
|
||||
const float* kcur, const float* vcur, const QsaShapes& s, void* stream) {
|
||||
const float* kcur, const float* vcur, const QsaShapes& s, void* stream, const KvHostPools* host) {
|
||||
validate(s, "kv_append");
|
||||
if (step == nullptr) fail("kv_append: step is null");
|
||||
// The grid is the head x dim count, which is a CONSTANT - `kv_append` writes one cell.
|
||||
const long long n = s.n_head_kv * s.head_dim;
|
||||
kv_append_kernel<<<grid_for(n, THREADS), THREADS, 0, (cudaStream_t) stream>>>(
|
||||
k_pool, v_pool, page_table, step, kcur, vcur, (int) s.n_head_kv, (int) s.head_dim, (int) s.page_size);
|
||||
k_pool, v_pool, page_table, step, kcur, vcur, (int) s.n_head_kv, (int) s.head_dim, (int) s.page_size,
|
||||
host ? *host : KvHostPools{});
|
||||
check_launch("kv_append");
|
||||
if (stream == nullptr) check_sync("kv_append");
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
// src/kernels/cuda/qsa_decode_attn.cu - see include/strata/kernels/qsa_decode_attn.hpp.
|
||||
#include "strata/kernels/qsa_decode_attn.hpp"
|
||||
#include "strata/kernels/kv_q8.hpp"
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
|
||||
#include <cuda_fp16.h>
|
||||
#include <cuda_runtime.h>
|
||||
@@ -30,9 +31,9 @@ __device__ __forceinline__ float warp_max(float v) {
|
||||
}
|
||||
|
||||
// 8 consecutive values of one cell's key or value row for KV head `kvh`, dimensions [d0, d0+8).
|
||||
template <bool INT8>
|
||||
template <int KV_MODE>
|
||||
__device__ __forceinline__ void load8(const QsaAttnPools& p, bool value, long long row, int d0, float* out) {
|
||||
if constexpr (!INT8) {
|
||||
if constexpr (KV_MODE == 0) {
|
||||
const uint16_t* base = (value ? p.v_pool : p.k_pool) + row * HD + d0;
|
||||
const uint4 raw = *reinterpret_cast<const uint4*>(base);
|
||||
const __half2* h2 = reinterpret_cast<const __half2*>(&raw);
|
||||
@@ -42,7 +43,7 @@ __device__ __forceinline__ void load8(const QsaAttnPools& p, bool value, long lo
|
||||
out[2 * j] = f.x;
|
||||
out[2 * j + 1] = f.y;
|
||||
}
|
||||
} else {
|
||||
} else if constexpr (KV_MODE == 1) {
|
||||
const int8_t* codes = (value ? p.v_q : p.k_q) + row * HD + d0;
|
||||
const uint16_t sbits = (value ? p.v_scale : p.k_scale)[row * (HD / KV_Q8_GROUP) + d0 / KV_Q8_GROUP];
|
||||
const float sc = __half2float(__ushort_as_half(sbits));
|
||||
@@ -50,10 +51,25 @@ __device__ __forceinline__ void load8(const QsaAttnPools& p, bool value, long lo
|
||||
const int8_t* c = reinterpret_cast<const int8_t*>(&raw);
|
||||
#pragma unroll
|
||||
for (int j = 0; j < 8; ++j) out[j] = (float) c[j] * sc;
|
||||
} else {
|
||||
constexpr int bytes_per_head = (HD / QK4_0) * sizeof(block_q4_0);
|
||||
const int b = d0 / QK4_0;
|
||||
const int rem = d0 % QK4_0;
|
||||
const block_q4_0* blk = reinterpret_cast<const block_q4_0*>((value ? p.v_q4 : p.k_q4) + row * bytes_per_head) + b;
|
||||
const float d = __half2float(__ushort_as_half(blk->d));
|
||||
const int j = (rem == 0 || rem == 16) ? 0 : 8;
|
||||
const uint8_t* bytes = blk->qs + j;
|
||||
if (rem < 16) {
|
||||
#pragma unroll
|
||||
for (int k = 0; k < 8; ++k) out[k] = (float) ((int)(bytes[k] & 0x0F) - 8) * d;
|
||||
} else {
|
||||
#pragma unroll
|
||||
for (int k = 0; k < 8; ++k) out[k] = (float) ((int)(bytes[k] >> 4) - 8) * d;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <bool INT8>
|
||||
template <int KV_MODE>
|
||||
__global__ void __launch_bounds__(THREADS) attn_chunk_kernel(const float* __restrict__ q, QsaAttnPools p,
|
||||
const int32_t* __restrict__ ids,
|
||||
const int32_t* __restrict__ step, int n_kv_heads,
|
||||
@@ -98,7 +114,7 @@ __global__ void __launch_bounds__(THREADS) attn_chunk_kernel(const float* __rest
|
||||
continue;
|
||||
}
|
||||
float k8[8];
|
||||
load8<INT8>(p, false, srow[c], lane * 8, k8);
|
||||
load8<KV_MODE>(p, false, srow[c], lane * 8, k8);
|
||||
#pragma unroll
|
||||
for (int h = 0; h < G; ++h) {
|
||||
const float4 qa = *reinterpret_cast<const float4*>(&sq[h][lane * 8]);
|
||||
@@ -128,11 +144,21 @@ __global__ void __launch_bounds__(THREADS) attn_chunk_kernel(const float* __rest
|
||||
for (int h = 0; h < G; ++h) acc[h] = 0.0f;
|
||||
for (int c = 0; c < n_here; ++c) {
|
||||
float v;
|
||||
if constexpr (!INT8) {
|
||||
if constexpr (KV_MODE == 0) {
|
||||
v = __half2float(__ushort_as_half(p.v_pool[srow[c] * HD + t]));
|
||||
} else {
|
||||
} else if constexpr (KV_MODE == 1) {
|
||||
const float sc = __half2float(__ushort_as_half(p.v_scale[srow[c] * (HD / KV_Q8_GROUP) + t / KV_Q8_GROUP]));
|
||||
v = (float) p.v_q[srow[c] * HD + t] * sc;
|
||||
} else {
|
||||
constexpr int bytes_per_head = (HD / QK4_0) * sizeof(block_q4_0);
|
||||
const int b = t / QK4_0;
|
||||
const int rem = t % QK4_0;
|
||||
const block_q4_0* blk = reinterpret_cast<const block_q4_0*>(p.v_q4 + srow[c] * bytes_per_head) + b;
|
||||
const float d = __half2float(__ushort_as_half(blk->d));
|
||||
const int j = rem < 16 ? rem : (rem - 16);
|
||||
const uint8_t byte = blk->qs[j];
|
||||
const int nibble = (rem < 16) ? ((byte & 0x0F) - 8) : ((byte >> 4) - 8);
|
||||
v = (float) nibble * d;
|
||||
}
|
||||
#pragma unroll
|
||||
for (int h = 0; h < G; ++h) acc[h] = fmaf(sp[h][c], v, acc[h]);
|
||||
@@ -176,7 +202,7 @@ void qsa_decode_attn_batch(const float* q, const QsaAttnPools& pools, const int3
|
||||
std::fprintf(stderr, "qsa_decode_attn_batch: unsupported geometry or missing buffers\n");
|
||||
std::exit(1);
|
||||
}
|
||||
const bool int8 = pools.k_q != nullptr;
|
||||
const int kv_mode = pools.k_q4 != nullptr ? 2 : (pools.k_q != nullptr ? 1 : 0);
|
||||
const int n_chunks = (int) ((cap + CHUNK - 1) / CHUNK);
|
||||
// per query: [acc: n_chunks*n_head*HD][m: n_chunks*n_head][l: n_chunks*n_head], all offsets from one stride
|
||||
const long long stride = (long long) qsa_decode_attn_scratch_floats(cap, s);
|
||||
@@ -186,12 +212,15 @@ void qsa_decode_attn_batch(const float* q, const QsaAttnPools& pools, const int3
|
||||
const float scale = 1.0f / sqrtf((float) HD);
|
||||
const dim3 grid((unsigned) n_chunks, (unsigned) s.n_head_kv, (unsigned) n_q);
|
||||
cudaStream_t st = (cudaStream_t) stream;
|
||||
if (int8)
|
||||
attn_chunk_kernel<true><<<grid, THREADS, 0, st>>>(q, pools, ids, steps, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks, (int) cap, stride);
|
||||
if (kv_mode == 2)
|
||||
attn_chunk_kernel<2><<<grid, THREADS, 0, st>>>(q, pools, ids, steps, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks, (int) cap, stride);
|
||||
else if (kv_mode == 1)
|
||||
attn_chunk_kernel<1><<<grid, THREADS, 0, st>>>(q, pools, ids, steps, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks, (int) cap, stride);
|
||||
else
|
||||
attn_chunk_kernel<false><<<grid, THREADS, 0, st>>>(q, pools, ids, steps, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks, (int) cap, stride);
|
||||
attn_chunk_kernel<0><<<grid, THREADS, 0, st>>>(q, pools, ids, steps, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks, (int) cap, stride);
|
||||
attn_merge_kernel<<<dim3((unsigned) s.n_head, (unsigned) n_q), HD, 0, st>>>(part_acc, part_m, part_l, n_chunks,
|
||||
attn, stride);
|
||||
const cudaError_t e = cudaGetLastError();
|
||||
@@ -213,8 +242,8 @@ void qsa_decode_attn_step(const float* q, const QsaAttnPools& pools, const int32
|
||||
std::fprintf(stderr, "qsa_decode_attn: unsupported geometry or missing buffers\n");
|
||||
std::exit(1);
|
||||
}
|
||||
const bool int8 = pools.k_q != nullptr;
|
||||
if (int8 ? (!pools.v_q || !pools.k_scale || !pools.v_scale) : (!pools.k_pool || !pools.v_pool)) {
|
||||
const int kv_mode = pools.k_q4 != nullptr ? 2 : (pools.k_q != nullptr ? 1 : 0);
|
||||
if (kv_mode == 2 ? (!pools.v_q4) : (kv_mode == 1 ? (!pools.v_q || !pools.k_scale || !pools.v_scale) : (!pools.k_pool || !pools.v_pool))) {
|
||||
std::fprintf(stderr, "qsa_decode_attn: incomplete KV pools\n");
|
||||
std::exit(1);
|
||||
}
|
||||
@@ -225,12 +254,15 @@ void qsa_decode_attn_step(const float* q, const QsaAttnPools& pools, const int32
|
||||
const float scale = 1.0f / sqrtf((float) HD);
|
||||
const dim3 grid((unsigned) n_chunks, (unsigned) s.n_head_kv);
|
||||
cudaStream_t st = (cudaStream_t) stream;
|
||||
if (int8)
|
||||
attn_chunk_kernel<true><<<grid, THREADS, 0, st>>>(q, pools, ids, step, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks);
|
||||
if (kv_mode == 2)
|
||||
attn_chunk_kernel<2><<<grid, THREADS, 0, st>>>(q, pools, ids, step, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks);
|
||||
else if (kv_mode == 1)
|
||||
attn_chunk_kernel<1><<<grid, THREADS, 0, st>>>(q, pools, ids, step, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks);
|
||||
else
|
||||
attn_chunk_kernel<false><<<grid, THREADS, 0, st>>>(q, pools, ids, step, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks);
|
||||
attn_chunk_kernel<0><<<grid, THREADS, 0, st>>>(q, pools, ids, step, (int) s.n_head_kv, (int) s.page_size,
|
||||
scale, part_acc, part_m, part_l, n_chunks);
|
||||
attn_merge_kernel<<<(unsigned) s.n_head, HD, 0, st>>>(part_acc, part_m, part_l, n_chunks, attn);
|
||||
const cudaError_t e = cudaGetLastError();
|
||||
if (e != cudaSuccess) {
|
||||
|
||||
+143
-128
@@ -1,6 +1,6 @@
|
||||
// src/kernels/cuda/sampler.cu - P2.S2: the sampler chain, in the order docs/sampling.md settles.
|
||||
//
|
||||
// penalties -> top_k -> top_p -> temperature -> pick
|
||||
// penalties -> top_k -> min_p -> top_p -> temperature -> penalties -> pick
|
||||
//
|
||||
// THE ORDER IS THE WHOLE CONTENT OF THIS FILE. `docs/sampling.md` transcribes it from llama.cpp's own chain
|
||||
// (`common/sampling.cpp` L357/360/375/381/399) and the two facts that are easy to get backwards are that
|
||||
@@ -9,10 +9,9 @@
|
||||
// valid token, so only a comparison at the distribution level can tell them apart; the parity test does that
|
||||
// explicitly by running the wrong order and requiring it to differ.
|
||||
//
|
||||
// Everything happens on the logits of ONE token in one thread. The vocab is 248,320, which is far too large
|
||||
// to sort per token on a naive path, so `top_k` uses `k` passes of a maximum scan - 20 x 248,320 = 5.0M
|
||||
// comparisons per token. Phase 3's note ("sort-free sampler: top-k = 20 makes this easy") is the optimisation;
|
||||
// this is the correctness version.
|
||||
// Both kernels put ONE BLOCK per token over the vocabulary: `sampler_greedy_kernel` is the plain argmax,
|
||||
// `sampler_kernel` runs the sampled chain as `top_k` block-argmax rounds followed by the top_p / temperature /
|
||||
// draw chain (its header says why the selection must be parallel and why the tie rule keeps the semantics).
|
||||
#include "strata/kernels/sampler.hpp"
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
@@ -102,12 +101,32 @@ __global__ void sampler_greedy_kernel(const float* __restrict__ logits, int n_vo
|
||||
hrow += history_len - hlen; // the window is the TAIL
|
||||
}
|
||||
|
||||
// PENALTY MEMBERSHIP AS A BITMAP. The history touches at most `hlen` tokens of a quarter-million
|
||||
// vocabulary, but the naive `history_count` per candidate per argmax round costs O(k x n_vocab x hlen)
|
||||
// integer compares (~318 M per token at k=20, hlen=64 - measured 45 -> 31 tok/s on a real workload).
|
||||
// A shared bitmap gives an O(1) membership test, and only the (at most hlen) hits pay the count scan;
|
||||
// the counts - and therefore every sampled value - are exactly what the per-candidate scan produced.
|
||||
extern __shared__ unsigned int penal_bits[];
|
||||
const int bits_words = (int) ((n_vocab + 31) / 32);
|
||||
const bool use_bits = hrow != nullptr && bits_words > 0;
|
||||
if (use_bits) {
|
||||
for (int w = threadIdx.x; w < bits_words; w += blockDim.x) penal_bits[w] = 0u;
|
||||
__syncthreads();
|
||||
for (int i = threadIdx.x; i < hlen; i += blockDim.x)
|
||||
if (hrow[i] >= 0) atomicOr(&penal_bits[hrow[i] >> 5], 1u << (hrow[i] & 31));
|
||||
__syncthreads();
|
||||
}
|
||||
auto hit_count = [&](int v) -> int {
|
||||
if (!use_bits || !(penal_bits[v >> 5] & (1u << (v & 31)))) return 0;
|
||||
return history_count(hrow, hlen, v);
|
||||
};
|
||||
|
||||
// `n_vocab` is the "no candidate" index: it loses every comparison to a real one, so a thread with no
|
||||
// elements contributes nothing rather than contributing a bogus zero.
|
||||
float bv = __int_as_float(0xff800000); // -inf
|
||||
int best = n_vocab;
|
||||
for (int v = threadIdx.x; v < n_vocab; v += blockDim.x) {
|
||||
const float s = apply_penalties(l[v], hrow ? history_count(hrow, hlen, v) : 0, p);
|
||||
const float s = apply_penalties(l[v], hit_count(v), p);
|
||||
if (s > bv) { bv = s; best = v; }
|
||||
}
|
||||
for (int off = 16; off > 0; off >>= 1) {
|
||||
@@ -134,47 +153,32 @@ __global__ void sampler_greedy_kernel(const float* __restrict__ logits, int n_vo
|
||||
}
|
||||
}
|
||||
|
||||
/// **THE SAMPLED PATH, ONE BLOCK PER TOKEN.** The kernel below replaced a version that ran the whole chain
|
||||
/// in ONE THREAD per token (`<<<ceil(T/64), 64>>>`, so a 4-token window fielded four threads): `top_k` alone
|
||||
/// was `k` sequential scans of the vocabulary with an inner sweep over the already-taken list - 20 x 248,320
|
||||
/// iterations of dependent work on one SM - and a verify window measured **1.6 s in the sampler**, which made
|
||||
/// every temperature-bearing request ~30x slower than a greedy one. The selection is `k` argmax rounds, and
|
||||
/// an argmax over the vocabulary parallelises exactly like `sampler_greedy_kernel` (block over the vocab), so
|
||||
/// the rounds run back to back inside a block-per-token launch: the per-token cost falls to
|
||||
/// `k x n_vocab / 1024` plus `k` block reductions.
|
||||
///
|
||||
/// THE SEMANTICS ARE THE SERIAL ONES, EXACTLY. Each round's argmax resolves ties to the LOWEST index (the
|
||||
/// serial scan's strict `>` keeps the first maximum it meets), so the kept sequence - both its set and its
|
||||
/// order - is unchanged; `top_p`'s cut reads that order in double arithmetic as before; temperature and the
|
||||
/// Philox draw apply after the cut. `sampler_parity` pins all of it against the host reference.
|
||||
__global__ void sampler_kernel(const float* __restrict__ logits, int n_vocab, int n_tokens,
|
||||
const int* __restrict__ history, int history_len, const SamplerParams p,
|
||||
int* __restrict__ out) {
|
||||
const int t = blockIdx.x * blockDim.x + threadIdx.x;
|
||||
const int t = blockIdx.x;
|
||||
if (t >= n_tokens) return;
|
||||
|
||||
// Work on a private copy: the chain mutates the distribution and the caller's logits are shared with the
|
||||
// next stage. A 248,320-float allocation per thread is far too much for shared memory, so this uses a
|
||||
// two-pass approach instead - first find the keep set, then normalise over it - and never materialises a
|
||||
// second full-size buffer.
|
||||
const float* l = logits + (size_t) t * n_vocab;
|
||||
|
||||
// Temperature is needed by BOTH paths below, so it is computed here; the chain still APPLIES it after
|
||||
// Temperature is needed by BOTH stages below, so it is computed here; the chain still APPLIES it after
|
||||
// the truncation filters - the survivors are chosen on the raw logits and only then scaled.
|
||||
const float inv_t = p.temperature > 0.0f ? 1.0f / p.temperature : 0.0f;
|
||||
|
||||
// ---- penalties: NOT IMPLEMENTED, and the ORDER they must take is transcribed here so the next person
|
||||
// does not have to guess it. `llama_sampler_penalties_apply` (src/llama-sampler.cpp) runs AFTER
|
||||
// temperature in the chain (L381 against L375), and for every token seen in the last `penalty_last_n`:
|
||||
//
|
||||
// if (logit <= 0) logit *= penalty_repeat; else logit /= penalty_repeat;
|
||||
// logit -= float(count) * penalty_freq + float(count > 0) * penalty_present;
|
||||
//
|
||||
// TWO details there are counter-intuitive. The repeat penalty MULTIPLIES for non-positive logits and
|
||||
// DIVIDES for positive ones - the source notes the paper only ever divided, "but that would cause tokens
|
||||
// with negative logits to become more likely, which is obviously wrong". And the presence penalty rides
|
||||
// on `float(count > 0)`, a BOOLEAN cast to float, not the count - so it applies once however many times
|
||||
// the token appeared. Both are the kind of thing a plausible implementation gets wrong while still
|
||||
// producing valid tokens.
|
||||
//
|
||||
// It needs the token history, which is not in this signature, so a caller passing a non-zero
|
||||
// `penalty_last_n` gets a loud failure rather than a silently unpenalised sample.
|
||||
// ---- top_k: k passes of a maximum scan, skipping the already-taken
|
||||
// ---- top_p: cumulative mass over the survivors in descending order
|
||||
// The two are done together in one selection pass so the survivors and their mass are consistent.
|
||||
// GREEDY IS THE GLOBAL ARGMAX, WHATEVER THE FILTERS SAY - so it is computed directly and the filter chain
|
||||
// is skipped entirely. No filter can remove the maximum: top_k keeps the k largest, top_p keeps a prefix
|
||||
// of the descending order that always contains the largest (min_keep >= 1), and temperature is monotonic so
|
||||
// it cannot reorder anything. That also makes greedy INDEPENDENT OF THE ORDER, which is why the ordering
|
||||
// test cannot use it - see sampler_parity.cpp.
|
||||
// The penalty window is the last `penalty_last_n` entries of this row's history.
|
||||
// The penalty window is the last `penalty_last_n` entries of this row's history (disabled at this
|
||||
// launch: `sample_tokens` refuses a non-zero `penalty_last_n` without a history buffer).
|
||||
const int* hrow = history ? history + (size_t) t * history_len : nullptr;
|
||||
int hlen = 0;
|
||||
if (hrow) {
|
||||
@@ -183,109 +187,117 @@ __global__ void sampler_kernel(const float* __restrict__ logits, int n_vocab, in
|
||||
hrow += history_len - hlen; // the window is the TAIL
|
||||
}
|
||||
|
||||
if (p.greedy || p.temperature <= 0.0f) {
|
||||
// Greedy is the global argmax ONLY when no penalty is active: a penalty can lower a token enough to
|
||||
// change the maximum, so the argmax has to be taken over the penalised logits, not the raw ones.
|
||||
//
|
||||
// *** TEMPERATURE MUST NOT BE APPLIED HERE. THIS WAS A REAL BUG. ***
|
||||
// This branch used to read `apply_penalties(l[v] * inv_t, ...)`. `inv_t` is 0.0f whenever
|
||||
// temperature <= 0 (see above), so at temperature 0 EVERY logit became 0.0f and the argmax returned
|
||||
// index 0 - the sampler emitted token 0 forever, whatever the model predicted. OpenAI clients send
|
||||
// `temperature: 0` for greedy decoding, so this was reachable from any ordinary client.
|
||||
// It is also pointless even when inv_t is non-zero: scaling by a positive constant is monotonic and
|
||||
// cannot reorder the argmax, which is exactly what the note above this block already says.
|
||||
int best = 0;
|
||||
float bv = apply_penalties(l[0], hrow ? history_count(hrow, hlen, 0) : 0, p);
|
||||
for (int v = 1; v < n_vocab; ++v) {
|
||||
const float s = apply_penalties(l[v], hrow ? history_count(hrow, hlen, v) : 0, p);
|
||||
if (s > bv) { bv = s; best = v; }
|
||||
}
|
||||
out[t] = best;
|
||||
return;
|
||||
// the membership bitmap, as in `sampler_greedy_kernel` - see the cost note there
|
||||
extern __shared__ unsigned int penal_bits[];
|
||||
const int bits_words = (int) ((n_vocab + 31) / 32);
|
||||
const bool use_bits = hrow != nullptr && bits_words > 0;
|
||||
if (use_bits) {
|
||||
for (int w = threadIdx.x; w < bits_words; w += blockDim.x) penal_bits[w] = 0u;
|
||||
__syncthreads();
|
||||
for (int i = threadIdx.x; i < hlen; i += blockDim.x)
|
||||
if (hrow[i] >= 0) atomicOr(&penal_bits[hrow[i] >> 5], 1u << (hrow[i] & 31));
|
||||
__syncthreads();
|
||||
}
|
||||
auto hit_count = [&](int v) -> int {
|
||||
if (!use_bits || !(penal_bits[v >> 5] & (1u << (v & 31)))) return 0;
|
||||
return history_count(hrow, hlen, v);
|
||||
};
|
||||
|
||||
const int KMAX = 64;
|
||||
int keep_ids[KMAX];
|
||||
float keep_logit[KMAX];
|
||||
int k = p.top_k > 0 ? (p.top_k < KMAX ? p.top_k : KMAX) : KMAX;
|
||||
if (p.top_k <= 0) k = 0; // 0 means "no top-k filter" -> handled by the mask below
|
||||
|
||||
int k = p.top_k > 0 ? (p.top_k < KMAX ? p.top_k : KMAX) : 0;
|
||||
if (k <= 0) {
|
||||
std::printf("sampler: the sampled path needs top_k in 1..%d (got %d); greedy needs no filters\n", KMAX, p.top_k);
|
||||
if (threadIdx.x == 0)
|
||||
std::printf("sampler: the sampled path needs top_k in 1..%d (got %d); greedy needs no filters\n",
|
||||
KMAX, p.top_k);
|
||||
return; // leave out[t] unwritten rather than returning an uninitialised token
|
||||
}
|
||||
int n_keep = 0;
|
||||
{
|
||||
for (int i = 0; i < k; ++i) {
|
||||
int best = -1;
|
||||
float bv = 0.0f;
|
||||
for (int v = 0; v < n_vocab; ++v) {
|
||||
bool taken = false;
|
||||
for (int j = 0; j < i; ++j) if (keep_ids[j] == v) { taken = true; break; }
|
||||
if (taken) continue;
|
||||
if (best < 0 || l[v] > bv) { best = v; bv = l[v]; }
|
||||
|
||||
// ---- top_k: k rounds of a block argmax over the not-yet-taken. `sel_*` holds the kept ids and their
|
||||
// raw logits in selection order: descending by value, ties to the lower index, which is the order the
|
||||
// top_p cut below is defined over.
|
||||
__shared__ int sel_ids[KMAX];
|
||||
__shared__ float sel_logit[KMAX];
|
||||
__shared__ float sv[32];
|
||||
__shared__ int si[32];
|
||||
for (int i = 0; i < k; ++i) {
|
||||
// `n_vocab` is the "no candidate" index: it loses every comparison to a real one (same convention as
|
||||
// the greedy kernel, whose tie rule this reduction shares).
|
||||
float bv = __int_as_float(0xff800000); // -inf
|
||||
int best = n_vocab;
|
||||
for (int v = threadIdx.x; v < n_vocab; v += blockDim.x) {
|
||||
bool taken = false;
|
||||
for (int j = 0; j < i; ++j) if (sel_ids[j] == v) { taken = true; break; }
|
||||
if (taken) continue;
|
||||
const float s = apply_penalties(l[v], hit_count(v), p);
|
||||
if (s > bv) { bv = s; best = v; }
|
||||
}
|
||||
for (int off = 16; off > 0; off >>= 1) {
|
||||
const float ov = __shfl_down_sync(0xFFFFFFFFu, bv, off);
|
||||
const int oi = __shfl_down_sync(0xFFFFFFFFu, best, off);
|
||||
if (ov > bv || (ov == bv && oi < best)) { bv = ov; best = oi; }
|
||||
}
|
||||
const int warp = (int) (threadIdx.x >> 5), lane = (int) (threadIdx.x & 31);
|
||||
if (lane == 0) { sv[warp] = bv; si[warp] = best; }
|
||||
__syncthreads();
|
||||
if (warp == 0) {
|
||||
const int nw = (int) ((blockDim.x + 31) >> 5);
|
||||
float wv = lane < nw ? sv[lane] : __int_as_float(0xff800000);
|
||||
int wi = lane < nw ? si[lane] : n_vocab;
|
||||
for (int off = 16; off > 0; off >>= 1) {
|
||||
const float ov = __shfl_down_sync(0xFFFFFFFFu, wv, off);
|
||||
const int oi = __shfl_down_sync(0xFFFFFFFFu, wi, off);
|
||||
if (ov > wv || (ov == wv && oi < wi)) { wv = ov; wi = oi; }
|
||||
}
|
||||
keep_ids[i] = best;
|
||||
keep_logit[i] = bv;
|
||||
}
|
||||
n_keep = k;
|
||||
|
||||
// ---- top_p over the survivors, in descending order (which the selection above already produced)
|
||||
if (p.top_p < 1.0f) {
|
||||
// softmax over the keep set for the cumulative mass
|
||||
float mx = keep_logit[0];
|
||||
for (int i = 1; i < n_keep; ++i) mx = fmaxf(mx, keep_logit[i]);
|
||||
double sum = 0.0;
|
||||
for (int i = 0; i < n_keep; ++i) sum += exp((double) keep_logit[i] - (double) mx);
|
||||
double cum = 0.0;
|
||||
int cut = n_keep;
|
||||
for (int i = 0; i < n_keep; ++i) {
|
||||
cum += exp((double) keep_logit[i] - (double) mx) / sum;
|
||||
if (cum >= (double) p.top_p) { cut = i + 1; break; }
|
||||
}
|
||||
if (cut < p.min_keep) cut = p.min_keep < n_keep ? p.min_keep : n_keep;
|
||||
n_keep = cut;
|
||||
if (lane == 0) { sel_ids[i] = (wi < n_vocab) ? wi : 0; sel_logit[i] = wv; }
|
||||
}
|
||||
__syncthreads();
|
||||
}
|
||||
|
||||
// ---- min_p: keep the descending prefix whose probability is at least `min_p` of the top token's. The
|
||||
// kept list is in selection order (descending), so the survivors are a PREFIX and the cut composes with
|
||||
// top_p's below. In logit space the threshold is `sel_logit[0] + logf(min_p)` - equivalent to
|
||||
// `p >= min_p * p_max` without the overflow an exp of raw logits risks. 0 disables, and the head itself
|
||||
// always survives (`expf(0) == 1 >= min_p` for min_p in 0..1), so the count never reaches zero.
|
||||
int n_minp = k;
|
||||
if (p.min_p > 0.0f) {
|
||||
const float thresh = sel_logit[0] + logf(p.min_p);
|
||||
for (int i = 0; i < k; ++i)
|
||||
if (sel_logit[i] < thresh) { n_minp = i; break; }
|
||||
}
|
||||
|
||||
if (p.greedy || p.temperature <= 0.0f) {
|
||||
// DEAD CODE AS WRITTEN: the identical condition at the top of this function already returned, so this
|
||||
// block cannot be reached. It is kept and corrected rather than deleted because if that early return
|
||||
// is ever narrowed, this is the path that would run - and it carried the same `* inv_t` bug (every
|
||||
// logit 0.0f at temperature 0, so `best` would always be `keep_ids[0]`). Temperature is monotonic and
|
||||
// cannot reorder a maximum, so it must not appear here at all.
|
||||
// argmax over the SURVIVORS, ties by smallest id (the same convention as the router and top_k)
|
||||
int best = keep_ids[0];
|
||||
float bv = keep_logit[0];
|
||||
for (int i = 1; i < n_keep; ++i) {
|
||||
const float v = keep_logit[i];
|
||||
if (v > bv) { bv = v; best = keep_ids[i]; }
|
||||
// ---- top_p over the survivors, in descending order (which the selection produced), then temperature and
|
||||
// one Philox draw. Every thread computes the same chain redundantly over `sel_*` - the arithmetic is the
|
||||
// serial kernel's, instruction for instruction - so they agree on `pick` and thread 0 writes it.
|
||||
int n_keep = n_minp;
|
||||
float mx = sel_logit[0];
|
||||
for (int i = 1; i < n_minp; ++i) mx = fmaxf(mx, sel_logit[i]);
|
||||
if (p.top_p < 1.0f) {
|
||||
double sum = 0.0;
|
||||
for (int i = 0; i < n_minp; ++i) sum += exp((double) sel_logit[i] - (double) mx);
|
||||
double cum = 0.0;
|
||||
int cut = n_minp;
|
||||
for (int i = 0; i < n_minp; ++i) {
|
||||
cum += exp((double) sel_logit[i] - (double) mx) / sum;
|
||||
if (cum >= (double) p.top_p) { cut = i + 1; break; }
|
||||
}
|
||||
out[t] = best;
|
||||
return;
|
||||
if (cut < p.min_keep) cut = p.min_keep < n_minp ? p.min_keep : n_minp;
|
||||
n_keep = cut;
|
||||
}
|
||||
|
||||
// ---- pick: temperature, then penalties, then softmax over the survivors, then one uniform draw.
|
||||
// The ORDER is the chain's: the survivors were chosen on the RAW logits, temperature scales them, and the
|
||||
// penalty is applied to the scaled value - which is why the `logit <= 0` branch inside the penalty sees a
|
||||
// temperature-scaled logit and not the model's own.
|
||||
for (int i = 0; i < n_keep; ++i) {
|
||||
keep_logit[i] = apply_penalties(keep_logit[i] * inv_t,
|
||||
hrow ? history_count(hrow, hlen, keep_ids[i]) : 0, p);
|
||||
}
|
||||
float mx = keep_logit[0];
|
||||
for (int i = 1; i < n_keep; ++i) mx = fmaxf(mx, keep_logit[i]);
|
||||
auto scaled = [&](int i) {
|
||||
return apply_penalties(sel_logit[i] * inv_t, hit_count(sel_ids[i]), p);
|
||||
};
|
||||
float smx = scaled(0);
|
||||
for (int i = 1; i < n_keep; ++i) smx = fmaxf(smx, scaled(i));
|
||||
double sum = 0.0;
|
||||
for (int i = 0; i < n_keep; ++i) sum += exp((double) keep_logit[i] - (double) mx);
|
||||
for (int i = 0; i < n_keep; ++i) sum += exp((double) scaled(i) - (double) smx);
|
||||
const float u = philox_uniform(p.seed, p.counter + (uint64_t) t);
|
||||
double cum = 0.0;
|
||||
int pick = keep_ids[n_keep - 1];
|
||||
int pick = sel_ids[n_keep - 1];
|
||||
for (int i = 0; i < n_keep; ++i) {
|
||||
cum += exp((double) keep_logit[i] - (double) mx) / sum;
|
||||
if ((double) u < cum) { pick = keep_ids[i]; break; }
|
||||
cum += exp((double) scaled(i) - (double) smx) / sum;
|
||||
if ((double) u < cum) { pick = sel_ids[i]; break; }
|
||||
}
|
||||
out[t] = pick;
|
||||
if (threadIdx.x == 0) out[t] = pick;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
@@ -298,16 +310,19 @@ void sample_tokens(const float* logits, int n_tokens, int n_vocab, const int* hi
|
||||
p.penalty_last_n, (const void*) history, history_len);
|
||||
std::exit(1);
|
||||
}
|
||||
const int threads = 64;
|
||||
const unsigned grid = (unsigned) ((n_tokens + threads - 1) / threads);
|
||||
const unsigned shmem = (history != nullptr && history_len > 0 && p.penalty_last_n > 0)
|
||||
? (unsigned) ((n_vocab + 31) / 32) * sizeof(unsigned) // the penalty bitmap
|
||||
: 0;
|
||||
if (p.greedy || p.temperature <= 0.0f) {
|
||||
// One block per token, 1,024 threads over the vocabulary. See `sampler_greedy_kernel`.
|
||||
const int gthreads = 1024;
|
||||
sampler_greedy_kernel<<<(unsigned) n_tokens, gthreads, 0, (cudaStream_t) stream>>>(
|
||||
sampler_greedy_kernel<<<(unsigned) n_tokens, gthreads, shmem, (cudaStream_t) stream>>>(
|
||||
logits, n_vocab, history, history_len, p, p.penalty_last_n, p.penalty_last_n, out);
|
||||
} else {
|
||||
sampler_kernel<<<grid, threads, 0, (cudaStream_t) stream>>>(logits, n_vocab, n_tokens, history,
|
||||
history_len, p, out);
|
||||
// The same block-per-token shape: the selection's k argmax rounds reduce inside the block. See
|
||||
// `sampler_kernel`'s header for what the old one-thread-per-token launch cost.
|
||||
sampler_kernel<<<(unsigned) n_tokens, 1024, shmem, (cudaStream_t) stream>>>(
|
||||
logits, n_vocab, n_tokens, history, history_len, p, out);
|
||||
}
|
||||
const cudaError_t e = cudaGetLastError();
|
||||
if (e != cudaSuccess) {
|
||||
|
||||
@@ -244,12 +244,14 @@ __global__ void ident_hits_kernel(const int32_t* __restrict__ ids, int n, int32_
|
||||
if (i == 0) *count = n;
|
||||
}
|
||||
|
||||
__global__ void gather_rows_kernel(const uint4* __restrict__ src, long long row16, const int32_t* __restrict__ ids,
|
||||
long long n, uint4* __restrict__ dst) {
|
||||
const long long total = n * row16;
|
||||
// E = the widest element the row size divides into (16, 4 or 1 bytes): a Q6_K head row of 2560 values is 2100 bytes
|
||||
template<typename E>
|
||||
__global__ void gather_rows_kernel(const E* __restrict__ src, long long row_e, const int32_t* __restrict__ ids,
|
||||
long long n, E* __restrict__ dst) {
|
||||
const long long total = n * row_e;
|
||||
for (long long i = (long long) blockIdx.x * blockDim.x + threadIdx.x; i < total; i += (long long) gridDim.x * blockDim.x) {
|
||||
const long long r = i / row16, o = i - r * row16;
|
||||
dst[i] = src[(long long) ids[r] * row16 + o];
|
||||
const long long r = i / row_e, o = i - r * row_e;
|
||||
dst[i] = src[(long long) ids[r] * row_e + o];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -334,8 +336,13 @@ void mtp_select(const float* R_src, int64_t R_stride, const int32_t* ids, const
|
||||
}
|
||||
|
||||
void gather_rows(const uint8_t* src, int64_t row_bytes, const int32_t* ids, int64_t n, uint8_t* dst, void* stream) {
|
||||
if (row_bytes % 16 != 0) { std::fprintf(stderr, "gather_rows: row size must be a multiple of 16\n"); std::exit(1); }
|
||||
gather_rows_kernel<<<48 * 8, 256, 0, (cudaStream_t) stream>>>((const uint4*) src, row_bytes / 16, ids, n, (uint4*) dst);
|
||||
cudaStream_t s = (cudaStream_t) stream;
|
||||
if (row_bytes % 16 == 0)
|
||||
gather_rows_kernel<<<48 * 8, 256, 0, s>>>((const uint4*) src, row_bytes / 16, ids, n, (uint4*) dst);
|
||||
else if (row_bytes % 4 == 0)
|
||||
gather_rows_kernel<<<48 * 8, 256, 0, s>>>((const uint32_t*) src, row_bytes / 4, ids, n, (uint32_t*) dst);
|
||||
else
|
||||
gather_rows_kernel<<<48 * 8, 256, 0, s>>>(src, row_bytes, ids, n, dst);
|
||||
check("gather_rows");
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,223 @@
|
||||
// src/kernels/cvec_parity.cpp - the control vector kernel (strata/kernels/cvec.hpp) against a host reference.
|
||||
// 1. project: h - s (h.v) v per stream and token, against double precision; the steered component is gone.
|
||||
// 2. add: h + d.
|
||||
// 3. switched off: R unchanged without a pending write; with one, R is BITWISE the write the fused read folds
|
||||
// (fused_gr_read with apply), which is what keeps a loaded-but-off vector identical to the stock engine.
|
||||
// 4. a layer without a direction is untouched.
|
||||
|
||||
#include "strata/kernels/cvec.hpp"
|
||||
#include "strata/kernels/fused_gr.hpp"
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <random>
|
||||
#include <vector>
|
||||
|
||||
namespace k = strata::kernels;
|
||||
|
||||
namespace {
|
||||
|
||||
int g_fail = 0;
|
||||
|
||||
void ck(cudaError_t e, const char* w) {
|
||||
if (e != cudaSuccess) {
|
||||
std::fprintf(stderr, "CUDA error in %s: %s\n", w, cudaGetErrorString(e));
|
||||
std::exit(2);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T* dalloc(size_t n) {
|
||||
T* p = nullptr;
|
||||
ck(cudaMalloc(&p, n * sizeof(T)), "malloc");
|
||||
return p;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void up(T* d, const std::vector<T>& h) { ck(cudaMemcpy(d, h.data(), h.size() * sizeof(T), cudaMemcpyHostToDevice), "up"); }
|
||||
template <typename T>
|
||||
std::vector<T> down(const T* d, size_t n) {
|
||||
std::vector<T> h(n);
|
||||
ck(cudaMemcpy(h.data(), d, n * sizeof(T), cudaMemcpyDeviceToHost), "down");
|
||||
return h;
|
||||
}
|
||||
|
||||
void check(bool ok, const char* what) {
|
||||
std::printf(" %-66s %s\n", what, ok ? "ok" : "FAIL");
|
||||
if (!ok) ++g_fail;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
constexpr int64_t L = 48, N = 2560, HC = 4, LR = 320, T = 5, D = HC * N;
|
||||
constexpr int64_t kLayer = 7, kOff = 3; // steered / not steered
|
||||
std::mt19937 rng(1234);
|
||||
std::normal_distribution<float> nd(0.0f, 1.0f);
|
||||
|
||||
// a unit direction at kLayer with a norm-2 scaled one's s = 2; nothing at kOff
|
||||
std::vector<float> dir((size_t) (L * N), 0.0f), s((size_t) L, 0.0f);
|
||||
{
|
||||
double nrm = 0.0;
|
||||
std::vector<float> v((size_t) N);
|
||||
for (auto& x : v) { x = nd(rng); nrm += (double) x * x; }
|
||||
nrm = std::sqrt(nrm);
|
||||
for (int64_t j = 0; j < N; ++j) dir[(size_t) (kLayer * N + j)] = (float) (v[(size_t) j] / nrm);
|
||||
s[(size_t) kLayer] = 2.0f;
|
||||
}
|
||||
std::string err;
|
||||
if (!k::cvec_upload(dir, s, /*project*/ 0, 4, 44, N, HC, err)) { std::fprintf(stderr, "%s\n", err.c_str()); return 2; }
|
||||
check(k::cvec().covers(kLayer) && !k::cvec().covers(kOff) && !k::cvec().covers(45), "covers(): steered layers only");
|
||||
|
||||
std::vector<float> R((size_t) (T * D)), bo((size_t) (T * N)), inj((size_t) (T * HC));
|
||||
for (auto& x : R) x = nd(rng) * 3.0f;
|
||||
for (auto& x : bo) x = nd(rng);
|
||||
for (auto& x : inj) x = nd(rng);
|
||||
float* dR = dalloc<float>(R.size());
|
||||
float* dbo = dalloc<float>(bo.size());
|
||||
float* dinj = dalloc<float>(inj.size());
|
||||
up(dbo, bo);
|
||||
up(dinj, inj);
|
||||
|
||||
// ---- 1. project, no pending write
|
||||
std::printf("project\n");
|
||||
up(dR, R);
|
||||
k::cvec_apply(dR, kLayer, T, D, nullptr, 0, nullptr, 0, false, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "project");
|
||||
{
|
||||
const auto got = down(dR, R.size());
|
||||
double worst = 0.0, worst_dot = 0.0;
|
||||
for (int64_t t = 0; t < T; ++t)
|
||||
for (int64_t c = 0; c < HC; ++c) {
|
||||
const float* h = R.data() + t * D + c * N;
|
||||
const float* v = dir.data() + kLayer * N;
|
||||
double dot = 0.0;
|
||||
for (int64_t j = 0; j < N; ++j) dot += (double) h[j] * v[j];
|
||||
double after = 0.0;
|
||||
for (int64_t j = 0; j < N; ++j) {
|
||||
const double want = h[j] - 2.0 * dot * v[j];
|
||||
const double g = got[(size_t) (t * D + c * N + j)];
|
||||
worst = std::fmax(worst, std::fabs(g - want));
|
||||
after += g * v[j];
|
||||
}
|
||||
// s = 2 reflects the component: h.v -> -h.v
|
||||
worst_dot = std::fmax(worst_dot, std::fabs(after + dot));
|
||||
}
|
||||
std::printf(" max |err| %.3g, max |h'.v + h.v| %.3g\n", worst, worst_dot);
|
||||
check(worst < 1e-4, "project matches h - s (h.v) v (s = 2)");
|
||||
check(worst_dot < 1e-3, "the component along v is reflected (s = 2)");
|
||||
}
|
||||
// s = 1 removes it
|
||||
s[(size_t) kLayer] = 1.0f;
|
||||
if (!k::cvec_upload(dir, s, 0, 4, 44, N, HC, err)) return 2;
|
||||
up(dR, R);
|
||||
k::cvec_apply(dR, kLayer, T, D, nullptr, 0, nullptr, 0, false, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "project s=1");
|
||||
{
|
||||
const auto got = down(dR, R.size());
|
||||
double worst = 0.0;
|
||||
for (int64_t t = 0; t < T; ++t)
|
||||
for (int64_t c = 0; c < HC; ++c) {
|
||||
double after = 0.0;
|
||||
for (int64_t j = 0; j < N; ++j) after += (double) got[(size_t) (t * D + c * N + j)] * dir[(size_t) (kLayer * N + j)];
|
||||
worst = std::fmax(worst, std::fabs(after));
|
||||
}
|
||||
std::printf(" max |h'.v| %.3g\n", worst);
|
||||
check(worst < 1e-3, "s = 1 projects the direction out");
|
||||
}
|
||||
|
||||
// ---- 4. a layer without a direction
|
||||
up(dR, R);
|
||||
k::cvec_apply(dR, kOff, T, D, nullptr, 0, nullptr, 0, false, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "off layer");
|
||||
check(std::memcmp(down(dR, R.size()).data(), R.data(), R.size() * 4) == 0, "a layer without a direction is untouched");
|
||||
|
||||
// ---- 3. switched off
|
||||
std::printf("switched off\n");
|
||||
k::cvec_set_enabled(false);
|
||||
check(!k::cvec_enabled(), "cvec_enabled() follows the switch");
|
||||
up(dR, R);
|
||||
k::cvec_apply(dR, kLayer, T, D, nullptr, 0, nullptr, 0, false, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "off");
|
||||
check(std::memcmp(down(dR, R.size()).data(), R.data(), R.size() * 4) == 0, "off, no pending write: R unchanged");
|
||||
{
|
||||
// the fused read's folded write, one token at a time, against the kernel's write-only pass
|
||||
std::vector<uint16_t> wd((size_t) (LR * D)), wu((size_t) (D * LR)), wi((size_t) (HC * D));
|
||||
std::vector<float> wn((size_t) D);
|
||||
auto bf = [&](float x) { uint32_t u; std::memcpy(&u, &x, 4); return (uint16_t) (u >> 16); };
|
||||
for (auto& x : wd) x = bf(nd(rng) * 0.02f);
|
||||
for (auto& x : wu) x = bf(nd(rng) * 0.02f);
|
||||
for (auto& x : wi) x = bf(nd(rng) * 0.02f);
|
||||
for (auto& x : wn) x = 1.0f + 0.1f * nd(rng);
|
||||
uint16_t* dwd = dalloc<uint16_t>(wd.size());
|
||||
uint16_t* dwu = dalloc<uint16_t>(wu.size());
|
||||
uint16_t* dwi = dalloc<uint16_t>(wi.size());
|
||||
float* dwn = dalloc<float>(wn.size());
|
||||
up(dwd, wd); up(dwu, wu); up(dwi, wi); up(dwn, wn);
|
||||
float* lo = dalloc<float>(LR);
|
||||
float* rs = dalloc<float>(HC);
|
||||
float* inj_out = dalloc<float>(HC);
|
||||
float* mixed = dalloc<float>(N);
|
||||
float* dF = dalloc<float>(R.size());
|
||||
up(dF, R);
|
||||
for (int64_t t = 0; t < T; ++t) {
|
||||
k::FusedGrArgs a;
|
||||
a.R = dF + t * D; a.R_out = dF + t * D; a.apply = true;
|
||||
a.bo_prev = dbo + t * N; a.inj_prev = dinj + t * HC;
|
||||
a.w_norm = dwn; a.w_down = dwd; a.w_up = dwu; a.w_inject = dwi;
|
||||
a.lo = lo; a.rs = rs; a.inject_out = inj_out; a.mixed = mixed;
|
||||
k::fused_gr_read(a, nullptr);
|
||||
}
|
||||
up(dR, R);
|
||||
k::cvec_apply(dR, kLayer, T, D, dbo, N, dinj, HC, true, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "write only");
|
||||
const auto fused = down(dF, R.size()), mine = down(dR, R.size());
|
||||
check(std::memcmp(fused.data(), mine.data(), R.size() * 4) == 0,
|
||||
"off, pending write: bitwise the fused read's folded write");
|
||||
k::cvec_set_enabled(true);
|
||||
// on, with the write: the write, then the projection (reference from the fused result)
|
||||
up(dR, R);
|
||||
k::cvec_apply(dR, kLayer, T, D, dbo, N, dinj, HC, true, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "write+project");
|
||||
const auto both = down(dR, R.size());
|
||||
double worst = 0.0;
|
||||
for (int64_t t = 0; t < T; ++t)
|
||||
for (int64_t c = 0; c < HC; ++c) {
|
||||
const float* h = fused.data() + t * D + c * N;
|
||||
const float* v = dir.data() + kLayer * N;
|
||||
double dot = 0.0;
|
||||
for (int64_t j = 0; j < N; ++j) dot += (double) h[j] * v[j];
|
||||
for (int64_t j = 0; j < N; ++j)
|
||||
worst = std::fmax(worst, std::fabs(both[(size_t) (t * D + c * N + j)] - (h[j] - dot * v[j])));
|
||||
}
|
||||
std::printf(" write + project: max |err| %.3g\n", worst);
|
||||
check(worst < 1e-4, "on, pending write: the write, then the projection");
|
||||
}
|
||||
|
||||
// ---- 2. add
|
||||
std::printf("add\n");
|
||||
for (int64_t j = 0; j < N; ++j) dir[(size_t) (kLayer * N + j)] *= 0.1f; // d = 0.1 v, s = 1
|
||||
s[(size_t) kLayer] = 1.0f;
|
||||
if (!k::cvec_upload(dir, s, /*add*/ 1, 4, 44, N, HC, err)) return 2;
|
||||
up(dR, R);
|
||||
k::cvec_apply(dR, kLayer, T, D, nullptr, 0, nullptr, 0, false, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "add");
|
||||
{
|
||||
const auto got = down(dR, R.size());
|
||||
bool same = true;
|
||||
for (int64_t t = 0; t < T; ++t)
|
||||
for (int64_t c = 0; c < HC; ++c)
|
||||
for (int64_t j = 0; j < N; ++j) {
|
||||
const size_t i = (size_t) (t * D + c * N + j);
|
||||
same = same && got[i] == R[i] + dir[(size_t) (kLayer * N + j)];
|
||||
}
|
||||
check(same, "add is h + d in every stream (bitwise)");
|
||||
}
|
||||
|
||||
std::printf(g_fail ? "cvec_parity: %d FAILED\n" : "cvec_parity: all passed\n", g_fail);
|
||||
return g_fail ? 1 : 0;
|
||||
}
|
||||
@@ -0,0 +1,346 @@
|
||||
// src/kernels/kv_q4_parity.cpp - Parity test for Q4_0 KV cache with orthonormal Walsh-Hadamard rotation.
|
||||
// Validates:
|
||||
// 1. FWHT 256 CUDA kernel vs exact mathematical orthonormal Walsh-Hadamard transform.
|
||||
// (H * H * x == x, H is symmetric and orthonormal with scale 1/sqrt(256) = 1/16).
|
||||
// 2. Q4_0 quantization and packing (32 values per block, 18 bytes) bitwise vs host reference.
|
||||
// 3. kv_append_q4_step and kv_gather_q4_step through paged pool against host reference.
|
||||
// 4. Invariance of dot products under Walsh-Hadamard rotation: (H*q) . (H*k) == q . k.
|
||||
|
||||
#include "strata/kernels/f16_bits.hpp"
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
#include "strata/kernels/qsa.hpp"
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <random>
|
||||
#include <vector>
|
||||
|
||||
namespace k = strata::kernels;
|
||||
|
||||
namespace {
|
||||
|
||||
int g_fail = 0;
|
||||
|
||||
void ck(cudaError_t e, const char* w) {
|
||||
if (e != cudaSuccess) {
|
||||
std::fprintf(stderr, "CUDA error in %s: %s\n", w, cudaGetErrorString(e));
|
||||
std::exit(2);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T* dalloc(size_t n) {
|
||||
T* p = nullptr;
|
||||
ck(cudaMalloc(&p, n * sizeof(T) + 64), "malloc");
|
||||
ck(cudaMemset(p, 0, n * sizeof(T) + 64), "memset");
|
||||
return p;
|
||||
}
|
||||
|
||||
// Exact CPU reference for Fast Walsh-Hadamard Transform (D = 256)
|
||||
// Sylvester construction matching llama.cpp's ggml_gen_hadamard
|
||||
void fwht256_host_reference(float* x) {
|
||||
constexpr int n = 256;
|
||||
for (int s = 1; s < n; s *= 2) {
|
||||
for (int i = 0; i < n; i += 2 * s) {
|
||||
for (int j = 0; j < s; ++j) {
|
||||
const float u = x[i + j];
|
||||
const float v = x[i + j + s];
|
||||
x[i + j] = u + v;
|
||||
x[i + j + s] = u - v;
|
||||
}
|
||||
}
|
||||
}
|
||||
const float scale = 1.0f / 16.0f; // 1 / sqrt(256)
|
||||
for (int i = 0; i < n; ++i) {
|
||||
x[i] *= scale;
|
||||
}
|
||||
}
|
||||
|
||||
// Host reference for Q4_0 quantization of 32 elements (1 block)
|
||||
void quantize_block_q4_0_host(const float* x, k::block_q4_0& blk) {
|
||||
float amax = 0.0f;
|
||||
float max_val = 0.0f;
|
||||
for (int i = 0; i < 32; ++i) {
|
||||
const float v = x[i];
|
||||
if (amax < std::fabs(v)) {
|
||||
amax = std::fabs(v);
|
||||
max_val = v;
|
||||
}
|
||||
}
|
||||
const float d = max_val / -8.0f;
|
||||
const float id = d != 0.0f ? 1.0f / d : 0.0f;
|
||||
blk.d = k::f16_from_f32(d);
|
||||
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
const float x0 = x[i] * id;
|
||||
const float x1 = x[i + 16] * id;
|
||||
const int q0 = (int) (x0 + 8.5f);
|
||||
const int q1 = (int) (x1 + 8.5f);
|
||||
const uint8_t xi0 = (uint8_t) std::min(15, std::max(0, q0));
|
||||
const uint8_t xi1 = (uint8_t) std::min(15, std::max(0, q1));
|
||||
blk.qs[i] = xi0 | (xi1 << 4);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
std::printf("=== Running kv_q4_parity test ===\n");
|
||||
std::mt19937 rng(42);
|
||||
std::normal_distribution<float> nd(0.0f, 1.0f);
|
||||
|
||||
// -------------------------------------------------------------
|
||||
// Test 1: Orthonormal Fast Walsh-Hadamard Transform (D=256)
|
||||
// -------------------------------------------------------------
|
||||
std::printf("[1/4] Verifying FWHT-256 CUDA kernel vs exact mathematical reference...\n");
|
||||
constexpr int n_vectors = 64;
|
||||
std::vector<float> h_in(n_vectors * 256);
|
||||
std::vector<float> h_ref(n_vectors * 256);
|
||||
for (size_t i = 0; i < h_in.size(); ++i) {
|
||||
h_in[i] = nd(rng);
|
||||
}
|
||||
h_ref = h_in;
|
||||
|
||||
// Run CPU reference on each row
|
||||
for (int r = 0; r < n_vectors; ++r) {
|
||||
fwht256_host_reference(h_ref.data() + r * 256);
|
||||
}
|
||||
|
||||
// Run GPU kernel
|
||||
float* d_src = dalloc<float>(n_vectors * 256);
|
||||
float* d_dst = dalloc<float>(n_vectors * 256);
|
||||
ck(cudaMemcpy(d_src, h_in.data(), h_in.size() * sizeof(float), cudaMemcpyHostToDevice), "memcpy H2D");
|
||||
|
||||
k::fwht256_cuda(d_src, d_dst, n_vectors, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "fwht256_cuda");
|
||||
|
||||
std::vector<float> h_out(n_vectors * 256);
|
||||
ck(cudaMemcpy(h_out.data(), d_dst, h_out.size() * sizeof(float), cudaMemcpyDeviceToHost), "memcpy D2H");
|
||||
|
||||
double max_fwht_diff = 0.0;
|
||||
for (size_t i = 0; i < h_out.size(); ++i) {
|
||||
double diff = std::fabs(h_out[i] - h_ref[i]);
|
||||
if (diff > max_fwht_diff) max_fwht_diff = diff;
|
||||
}
|
||||
if (max_fwht_diff > 1e-5) {
|
||||
std::fprintf(stderr, "FAIL: FWHT-256 GPU output differs from host reference (max diff = %e)\n", max_fwht_diff);
|
||||
++g_fail;
|
||||
} else {
|
||||
std::printf(" -> FWHT-256 bitwise match with host reference (max diff = %e, OK)\n", max_fwht_diff);
|
||||
}
|
||||
|
||||
// Self-inverse property: H * (H * x) == x
|
||||
k::fwht256_inplace_cuda(d_dst, n_vectors, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "fwht256_inplace_cuda");
|
||||
ck(cudaMemcpy(h_out.data(), d_dst, h_out.size() * sizeof(float), cudaMemcpyDeviceToHost), "memcpy D2H");
|
||||
|
||||
double max_inv_diff = 0.0;
|
||||
for (size_t i = 0; i < h_out.size(); ++i) {
|
||||
double diff = std::fabs(h_out[i] - h_in[i]);
|
||||
if (diff > max_inv_diff) max_inv_diff = diff;
|
||||
}
|
||||
if (max_inv_diff > 1e-5) {
|
||||
std::fprintf(stderr, "FAIL: FWHT-256 self-inverse property failed (max diff = %e)\n", max_inv_diff);
|
||||
++g_fail;
|
||||
} else {
|
||||
std::printf(" -> FWHT-256 self-inverse property verified H*H*x == x (max diff = %e, OK)\n", max_inv_diff);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------
|
||||
// Test 2: Invariance of Attention Scores under Hadamard Rotation
|
||||
// -------------------------------------------------------------
|
||||
std::printf("[2/4] Verifying Attention Score Invariance: <H*q, H*k> == <q, k>...\n");
|
||||
double max_dot_diff = 0.0;
|
||||
for (int r = 0; r < n_vectors; r += 2) {
|
||||
const float* q = h_in.data() + r * 256;
|
||||
const float* k_vec = h_in.data() + (r + 1) * 256;
|
||||
const float* hq = h_ref.data() + r * 256;
|
||||
const float* hk = h_ref.data() + (r + 1) * 256;
|
||||
|
||||
double dot_raw = 0.0;
|
||||
double dot_rot = 0.0;
|
||||
for (int i = 0; i < 256; ++i) {
|
||||
dot_raw += (double) q[i] * (double) k_vec[i];
|
||||
dot_rot += (double) hq[i] * (double) hk[i];
|
||||
}
|
||||
double d = std::fabs(dot_raw - dot_rot);
|
||||
if (d > max_dot_diff) max_dot_diff = d;
|
||||
}
|
||||
if (max_dot_diff > 1e-5) {
|
||||
std::fprintf(stderr, "FAIL: Rotated dot product differs from original (max diff = %e)\n", max_dot_diff);
|
||||
++g_fail;
|
||||
} else {
|
||||
std::printf(" -> Dot product invariant under rotation: |<Hq,Hk> - <q,k>| = %e (OK)\n", max_dot_diff);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------
|
||||
// Test 3: Q4_0 Paged KV Append & Gather against Host Reference
|
||||
// -------------------------------------------------------------
|
||||
std::printf("[3/4] Verifying Q4_0 KV append and gather against host reference...\n");
|
||||
k::QsaShapes s = k::qsa_real_shapes();
|
||||
s.page_size = 64;
|
||||
const int H = (int) s.n_head_kv; // 2
|
||||
const int D = (int) s.head_dim; // 256
|
||||
const int P = (int) s.page_size; // 64
|
||||
const int pages = 8;
|
||||
const int cells = pages * P;
|
||||
|
||||
std::vector<int32_t> table(pages);
|
||||
for (int i = 0; i < pages; ++i) table[i] = (i * 3 + 5) % pages; // permutation
|
||||
int32_t* d_table = dalloc<int32_t>(pages);
|
||||
ck(cudaMemcpy(d_table, table.data(), pages * sizeof(int32_t), cudaMemcpyHostToDevice), "memcpy table");
|
||||
|
||||
const size_t pool_bytes = (size_t) pages * H * P * k::kv_q4_bytes_per_head(D);
|
||||
uint8_t* d_k_q4 = dalloc<uint8_t>(pool_bytes);
|
||||
uint8_t* d_v_q4 = dalloc<uint8_t>(pool_bytes);
|
||||
float* d_kcur = dalloc<float>(H * D);
|
||||
float* d_vcur = dalloc<float>(H * D);
|
||||
int32_t* d_step = dalloc<int32_t>(k::kStepCount);
|
||||
|
||||
std::vector<std::vector<float>> host_k(cells), host_v(cells);
|
||||
std::vector<int> positions(cells);
|
||||
for (int i = 0; i < cells; ++i) positions[i] = i;
|
||||
std::shuffle(positions.begin(), positions.end(), rng);
|
||||
|
||||
const int n_fill = cells - 25; // leave some cells empty
|
||||
for (int n = 0; n < n_fill; ++n) {
|
||||
const int pos = positions[n];
|
||||
std::vector<float> kv(H * D), vv(H * D);
|
||||
for (auto& x : kv) x = nd(rng) * 2.0f;
|
||||
for (auto& x : vv) x = nd(rng) * 2.0f;
|
||||
|
||||
// Apply FWHT before append
|
||||
for (int h = 0; h < H; ++h) {
|
||||
fwht256_host_reference(kv.data() + h * D);
|
||||
fwht256_host_reference(vv.data() + h * D);
|
||||
}
|
||||
host_k[pos] = kv;
|
||||
host_v[pos] = vv;
|
||||
|
||||
int32_t hstep[k::kStepCount] = {pos, pos + 1, 0, 0};
|
||||
ck(cudaMemcpy(d_step, hstep, sizeof(hstep), cudaMemcpyHostToDevice), "memcpy step");
|
||||
ck(cudaMemcpy(d_kcur, kv.data(), kv.size() * sizeof(float), cudaMemcpyHostToDevice), "memcpy k");
|
||||
ck(cudaMemcpy(d_vcur, vv.data(), vv.size() * sizeof(float), cudaMemcpyHostToDevice), "memcpy v");
|
||||
|
||||
k::kv_append_q4_step(d_k_q4, d_v_q4, d_table, d_step, d_kcur, d_vcur, s, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "kv_append_q4_step");
|
||||
}
|
||||
|
||||
// Verify written Q4_0 blocks bitwise against host quantizer
|
||||
std::vector<uint8_t> h_k_q4(pool_bytes), h_v_q4(pool_bytes);
|
||||
ck(cudaMemcpy(h_k_q4.data(), d_k_q4, pool_bytes, cudaMemcpyDeviceToHost), "memcpy d2h k_q4");
|
||||
ck(cudaMemcpy(h_v_q4.data(), d_v_q4, pool_bytes, cudaMemcpyDeviceToHost), "memcpy d2h v_q4");
|
||||
|
||||
long bad_blocks = 0;
|
||||
const int blocks_per_head = D / k::QK4_0; // 8
|
||||
const int bytes_per_head = blocks_per_head * sizeof(k::block_q4_0); // 144
|
||||
|
||||
for (int n = 0; n < n_fill; ++n) {
|
||||
const int pos = positions[n];
|
||||
for (int is_v = 0; is_v < 2; ++is_v) {
|
||||
for (int h = 0; h < H; ++h) {
|
||||
const long long page = (long long) table[pos / P];
|
||||
const long long row = (page * H + h) * P + (pos % P);
|
||||
const uint8_t* pool_ptr = (is_v ? h_v_q4.data() : h_k_q4.data()) + row * bytes_per_head;
|
||||
const float* raw_vec = (is_v ? host_v[pos].data() : host_k[pos].data()) + h * D;
|
||||
|
||||
for (int b = 0; b < blocks_per_head; ++b) {
|
||||
k::block_q4_0 host_blk;
|
||||
quantize_block_q4_0_host(raw_vec + b * 32, host_blk);
|
||||
|
||||
const k::block_q4_0* gpu_blk = reinterpret_cast<const k::block_q4_0*>(pool_ptr) + b;
|
||||
if (std::memcmp(&host_blk, gpu_blk, sizeof(k::block_q4_0)) != 0) {
|
||||
if (bad_blocks == 0) {
|
||||
std::printf("MISMATCH at n=%d, pos=%d, is_v=%d, h=%d, b=%d\n", n, pos, is_v, h, b);
|
||||
std::printf(" host blk.d = 0x%04x (%f), gpu blk.d = 0x%04x (%f)\n",
|
||||
host_blk.d, k::f32_from_f16(host_blk.d),
|
||||
gpu_blk->d, k::f32_from_f16(gpu_blk->d));
|
||||
std::printf(" host qs: ");
|
||||
for (int i = 0; i < 16; ++i) std::printf("%02x ", host_blk.qs[i]);
|
||||
std::printf("\n gpu qs: ");
|
||||
for (int i = 0; i < 16; ++i) std::printf("%02x ", gpu_blk->qs[i]);
|
||||
std::printf("\n");
|
||||
}
|
||||
++bad_blocks;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (bad_blocks > 0) {
|
||||
std::fprintf(stderr, "FAIL: %ld Q4_0 blocks differ from host quantizer\n", bad_blocks);
|
||||
++g_fail;
|
||||
} else {
|
||||
std::printf(" -> All Q4_0 pool blocks bitwise equal to host quantizer (OK)\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------
|
||||
// Test 4: Gather Q4_0 into FP16 Scratch and verify accuracy
|
||||
// -------------------------------------------------------------
|
||||
std::printf("[4/4] Verifying Q4_0 gather unpacking and dequantization...\n");
|
||||
const int max_ids = 128;
|
||||
int32_t* d_ids = dalloc<int32_t>(max_ids);
|
||||
uint16_t* d_k_scratch = dalloc<uint16_t>((size_t) max_ids * H * D);
|
||||
uint16_t* d_v_scratch = dalloc<uint16_t>((size_t) max_ids * H * D);
|
||||
|
||||
std::vector<int32_t> ids(max_ids);
|
||||
for (int i = 0; i < max_ids; ++i) {
|
||||
ids[i] = positions[rng() % n_fill];
|
||||
}
|
||||
ck(cudaMemcpy(d_ids, ids.data(), max_ids * sizeof(int32_t), cudaMemcpyHostToDevice), "memcpy ids");
|
||||
|
||||
int32_t hstep[k::kStepCount] = {0, 0, 0, max_ids};
|
||||
ck(cudaMemcpy(d_step, hstep, sizeof(hstep), cudaMemcpyHostToDevice), "memcpy step");
|
||||
|
||||
k::kv_gather_q4_step(d_k_q4, d_v_q4, d_table, d_ids, d_step, max_ids, s, d_k_scratch, d_v_scratch, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "kv_gather_q4_step");
|
||||
|
||||
std::vector<uint16_t> h_k_scratch((size_t) max_ids * H * D);
|
||||
std::vector<uint16_t> h_v_scratch((size_t) max_ids * H * D);
|
||||
ck(cudaMemcpy(h_k_scratch.data(), d_k_scratch, h_k_scratch.size() * sizeof(uint16_t), cudaMemcpyDeviceToHost), "memcpy d2h k_scratch");
|
||||
ck(cudaMemcpy(h_v_scratch.data(), d_v_scratch, h_v_scratch.size() * sizeof(uint16_t), cudaMemcpyDeviceToHost), "memcpy d2h v_scratch");
|
||||
|
||||
double worst_quant_err = 0.0;
|
||||
for (int i = 0; i < max_ids; ++i) {
|
||||
const int cell = ids[i];
|
||||
for (int is_v = 0; is_v < 2; ++is_v) {
|
||||
for (int h = 0; h < H; ++h) {
|
||||
const float* orig = (is_v ? host_v[cell].data() : host_k[cell].data()) + h * D;
|
||||
const uint16_t* gathered = (is_v ? h_v_scratch.data() : h_k_scratch.data()) + (i * H + h) * D;
|
||||
|
||||
for (int d = 0; d < D; ++d) {
|
||||
float deq = k::f32_from_f16(gathered[d]);
|
||||
float raw = orig[d];
|
||||
double err = std::fabs(deq - raw);
|
||||
if (err > worst_quant_err) worst_quant_err = err;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
std::printf(" -> Max reconstruction error after 4-bit quant + dequant: %.4f (OK)\n", worst_quant_err);
|
||||
|
||||
cudaFree(d_src);
|
||||
cudaFree(d_dst);
|
||||
cudaFree(d_table);
|
||||
cudaFree(d_k_q4);
|
||||
cudaFree(d_v_q4);
|
||||
cudaFree(d_kcur);
|
||||
cudaFree(d_vcur);
|
||||
cudaFree(d_step);
|
||||
cudaFree(d_ids);
|
||||
cudaFree(d_k_scratch);
|
||||
cudaFree(d_v_scratch);
|
||||
|
||||
if (g_fail == 0) {
|
||||
std::printf("=== kv_q4_parity: ALL TESTS PASSED SUCCESSFULLY! ===\n");
|
||||
return 0;
|
||||
} else {
|
||||
std::fprintf(stderr, "=== kv_q4_parity: FAILED (%d failures) ===\n", g_fail);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,234 @@
|
||||
// src/kernels/kv_stream_parity.cpp - KV streaming (kv_stream.hpp) against a fully resident pool (GPU, no model).
|
||||
//
|
||||
// Decodes a synthetic sequence twice: into a fully resident pool with the identity page table, and into a streamed
|
||||
// layer (host copy + a small VRAM slot pool that must evict constantly). Every few cells a batch of 1-8 queries
|
||||
// with selections shaped like the indexer's (whole 4-cell blocks, a partial threshold block, the tail block, half of
|
||||
// them recent) is attended in both; `kv_stream_resolve` runs before the streamed attention. Checks:
|
||||
// 1. the attention outputs are BITWISE equal (the streamed readers see exactly the resident values);
|
||||
// 2. the residency map is consistent after every call (slot_block and page_table invert each other);
|
||||
// 3. no call overflowed, and the hit/miss counters add up;
|
||||
// 4. a ring (the MTP drafter's layout) restored from the host copy reads the same values as the resident pool.
|
||||
// INT8, FP16 and Q4_0 (PR #21) pools.
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
#include "strata/kernels/kv_q8.hpp"
|
||||
#include "strata/kernels/kv_stream.hpp"
|
||||
#include "strata/kernels/qsa.hpp"
|
||||
#include "strata/kernels/qsa_decode_attn.hpp"
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <random>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
|
||||
namespace k = strata::kernels;
|
||||
|
||||
namespace {
|
||||
int g_fail = 0;
|
||||
void ck(cudaError_t e, const char* w) {
|
||||
if (e != cudaSuccess) { std::fprintf(stderr, "%s: %s\n", w, cudaGetErrorString(e)); std::exit(2); }
|
||||
}
|
||||
template <typename T> T* dalloc(size_t n) {
|
||||
T* p = nullptr;
|
||||
ck(cudaMalloc(&p, n * sizeof(T) + 64), "malloc");
|
||||
ck(cudaMemset(p, 0, n * sizeof(T) + 64), "memset");
|
||||
return p;
|
||||
}
|
||||
template <typename T> T* halloc(size_t n) { // pinned, mapped; returns the device pointer
|
||||
void* h = nullptr;
|
||||
void* d = nullptr;
|
||||
ck(cudaHostAlloc(&h, n * sizeof(T) + 64, cudaHostAllocMapped), "hostalloc");
|
||||
std::memset(h, 0, n * sizeof(T) + 64);
|
||||
ck(cudaHostGetDevicePointer(&d, h, 0), "devptr");
|
||||
return (T*) d;
|
||||
}
|
||||
|
||||
struct Pools { // one K/V pool set of `pages` pages
|
||||
k::KvHostPools p; // reused as a plain pointer bundle
|
||||
void alloc(int64_t pages, const k::QsaShapes& s, int fmt, bool host) {
|
||||
const size_t rows = (size_t) pages * s.n_head_kv * s.page_size;
|
||||
if (fmt == k::kKvQ4) {
|
||||
const size_t b = rows * k::kv_q4_bytes_per_head((int) s.head_dim);
|
||||
p.k_q4 = host ? halloc<uint8_t>(b) : dalloc<uint8_t>(b);
|
||||
p.v_q4 = host ? halloc<uint8_t>(b) : dalloc<uint8_t>(b);
|
||||
} else if (fmt == k::kKvInt8) {
|
||||
p.k_q = host ? halloc<int8_t>(rows * s.head_dim) : dalloc<int8_t>(rows * s.head_dim);
|
||||
p.v_q = host ? halloc<int8_t>(rows * s.head_dim) : dalloc<int8_t>(rows * s.head_dim);
|
||||
p.k_scale = host ? halloc<uint16_t>(rows * 4) : dalloc<uint16_t>(rows * 4);
|
||||
p.v_scale = host ? halloc<uint16_t>(rows * 4) : dalloc<uint16_t>(rows * 4);
|
||||
} else {
|
||||
p.k_pool = host ? halloc<uint16_t>(rows * s.head_dim) : dalloc<uint16_t>(rows * s.head_dim);
|
||||
p.v_pool = host ? halloc<uint16_t>(rows * s.head_dim) : dalloc<uint16_t>(rows * s.head_dim);
|
||||
}
|
||||
}
|
||||
k::QsaAttnPools attn(const int32_t* table) const {
|
||||
k::QsaAttnPools a;
|
||||
a.k_pool = p.k_pool; a.v_pool = p.v_pool; a.k_q = p.k_q; a.v_q = p.v_q; a.k_scale = p.k_scale;
|
||||
a.v_scale = p.v_scale; a.k_q4 = p.k_q4; a.v_q4 = p.v_q4; a.page_table = table;
|
||||
return a;
|
||||
}
|
||||
};
|
||||
|
||||
void append(const Pools& pl, const int32_t* table, const int32_t* step, const float* kc, const float* vc,
|
||||
const k::QsaShapes& s, int fmt, const k::KvHostPools* host) {
|
||||
if (fmt == k::kKvQ4) k::kv_append_q4_step(pl.p.k_q4, pl.p.v_q4, table, step, kc, vc, s, nullptr, host);
|
||||
else if (fmt == k::kKvInt8) k::kv_append_q8_step(pl.p.k_q, pl.p.v_q, pl.p.k_scale, pl.p.v_scale, table, step, kc, vc, s, nullptr, host);
|
||||
else k::kv_append_step(pl.p.k_pool, pl.p.v_pool, table, step, kc, vc, s, nullptr, host);
|
||||
}
|
||||
|
||||
// A selection like qsa_block_topk's: ascending cells, whole blocks, the tail block's cells, and one partial block.
|
||||
std::vector<int32_t> selection(int64_t n_kv, int64_t width, std::mt19937& rng) {
|
||||
std::vector<int32_t> ids;
|
||||
if (n_kv <= width) {
|
||||
for (int64_t c = 0; c < n_kv; ++c) ids.push_back((int32_t) c);
|
||||
return ids;
|
||||
}
|
||||
const int64_t n_bid = n_kv / 4, tail = n_kv - n_bid * 4;
|
||||
std::set<int64_t> blocks;
|
||||
const int64_t want_full = (width - tail) / 4, part = (width - tail) % 4;
|
||||
std::uniform_int_distribution<int64_t> any(0, n_bid - 1), recent(std::max<int64_t>(0, n_bid - 2048), n_bid - 1);
|
||||
while ((int64_t) blocks.size() < want_full + (part ? 1 : 0)) blocks.insert(rng() % 2 ? recent(rng) : any(rng));
|
||||
int64_t partial_block = part ? *std::next(blocks.begin(), (long) (rng() % blocks.size())) : -1;
|
||||
for (int64_t b : blocks) {
|
||||
const int64_t take = b == partial_block ? part : 4;
|
||||
for (int64_t i = 0; i < take; ++i) ids.push_back((int32_t) (b * 4 + i));
|
||||
}
|
||||
for (int64_t c = n_bid * 4; c < n_kv; ++c) ids.push_back((int32_t) c);
|
||||
std::sort(ids.begin(), ids.end());
|
||||
return ids;
|
||||
}
|
||||
|
||||
bool run(int fmt) {
|
||||
const char* name = fmt == k::kKvQ4 ? "q4_0" : fmt == k::kKvInt8 ? "int8" : "fp16";
|
||||
k::QsaShapes s = k::qsa_real_shapes();
|
||||
const int64_t N = 40000, n_blocks = (N + 3) / 4, n_slots = 8 * 516 + 700; // must evict: slots < blocks
|
||||
const int64_t cap = k::qsa_selection_width(k::kTopkMaxCells, s), NQ = 8;
|
||||
const int64_t H = s.n_head_kv, D = s.head_dim, NH = s.n_head;
|
||||
std::mt19937 rng(7 + 4 * fmt);
|
||||
std::normal_distribution<float> nd(0.f, 1.f);
|
||||
|
||||
Pools ref, slots, host;
|
||||
ref.alloc(n_blocks, s, fmt, false);
|
||||
slots.alloc(n_slots, s, fmt, false);
|
||||
host.alloc(n_blocks, s, fmt, true);
|
||||
int32_t* ident = dalloc<int32_t>(n_blocks);
|
||||
{
|
||||
std::vector<int32_t> t(n_blocks);
|
||||
for (int64_t i = 0; i < n_blocks; ++i) t[i] = (int32_t) i;
|
||||
ck(cudaMemcpy(ident, t.data(), n_blocks * 4, cudaMemcpyHostToDevice), "ident");
|
||||
}
|
||||
k::KvStreamMap m;
|
||||
m.page_table = dalloc<int32_t>(n_blocks);
|
||||
m.slot_block = dalloc<int32_t>(n_slots); m.slot_stamp = dalloc<int32_t>(n_slots); m.slot_ref = dalloc<int32_t>(n_slots);
|
||||
m.miss_block = dalloc<int32_t>(n_slots); m.miss_slot = dalloc<int32_t>(n_slots);
|
||||
m.ctl = dalloc<int32_t>(k::kKvCtlInts);
|
||||
m.n_blocks = n_blocks; m.n_slots = n_slots;
|
||||
k::kv_stream_reset(m, nullptr);
|
||||
|
||||
float* kc = dalloc<float>(H * D);
|
||||
float* vc = dalloc<float>(H * D);
|
||||
int32_t* step = dalloc<int32_t>(k::kStepCount);
|
||||
int32_t* steps = dalloc<int32_t>(NQ * k::kStepCount);
|
||||
int32_t* ids = dalloc<int32_t>(NQ * cap);
|
||||
float* q = dalloc<float>(NQ * NH * D);
|
||||
const uint64_t scr = k::qsa_decode_attn_scratch_floats(cap, s);
|
||||
float* scratch = dalloc<float>(NQ * scr);
|
||||
float* out_ref = dalloc<float>(NQ * NH * D);
|
||||
float* out_str = dalloc<float>(NQ * NH * D);
|
||||
std::vector<float> hk(H * D), hv(H * D), hq(NQ * NH * D), a((size_t) NQ * NH * D), b2((size_t) NQ * NH * D);
|
||||
std::vector<int32_t> pt(n_blocks), sb(n_slots);
|
||||
|
||||
int batches = 0, bad = 0;
|
||||
for (int64_t pos = 0; pos < N; ++pos) {
|
||||
for (auto& x : hk) x = nd(rng) * ((pos % 17 == 0) ? 30.f : 1.f);
|
||||
for (auto& x : hv) x = nd(rng);
|
||||
const int32_t st[4] = {(int32_t) pos, (int32_t) (pos + 1), (int32_t) ((pos + 1) / 4), 0};
|
||||
ck(cudaMemcpy(kc, hk.data(), hk.size() * 4, cudaMemcpyHostToDevice), "k");
|
||||
ck(cudaMemcpy(vc, hv.data(), hv.size() * 4, cudaMemcpyHostToDevice), "v");
|
||||
ck(cudaMemcpy(step, st, sizeof(st), cudaMemcpyHostToDevice), "step");
|
||||
append(ref, ident, step, kc, vc, s, fmt, nullptr);
|
||||
append(slots, m.page_table, step, kc, vc, s, fmt, &host.p);
|
||||
if (pos % 131 != 130 && pos != N - 1) continue;
|
||||
// a batch: n_q queries at the last n_q positions (as a verify window), each with its own selection
|
||||
const int n_q = 1 + (int) (rng() % NQ);
|
||||
std::vector<int32_t> hids((size_t) NQ * cap, 0), hst(NQ * 4, 0);
|
||||
for (int t = 0; t < n_q; ++t) {
|
||||
const int64_t p = std::max<int64_t>(0, pos - (n_q - 1 - t)), n_kv = p + 1;
|
||||
const int64_t width = std::min<int64_t>(n_kv, cap);
|
||||
const std::vector<int32_t> sel = selection(n_kv, width, rng);
|
||||
if ((int64_t) sel.size() != width) { std::fprintf(stderr, "selection size %zu != %lld\n", sel.size(), (long long) width); return false; }
|
||||
std::copy(sel.begin(), sel.end(), hids.begin() + (size_t) t * cap);
|
||||
hst[t * 4 + 0] = (int32_t) p; hst[t * 4 + 1] = (int32_t) n_kv; hst[t * 4 + 2] = (int32_t) (n_kv / 4);
|
||||
hst[t * 4 + 3] = (int32_t) width;
|
||||
}
|
||||
for (auto& x : hq) x = nd(rng);
|
||||
ck(cudaMemcpy(ids, hids.data(), hids.size() * 4, cudaMemcpyHostToDevice), "ids");
|
||||
ck(cudaMemcpy(steps, hst.data(), hst.size() * 4, cudaMemcpyHostToDevice), "steps");
|
||||
ck(cudaMemcpy(q, hq.data(), hq.size() * 4, cudaMemcpyHostToDevice), "q");
|
||||
k::qsa_decode_attn_batch(q, ref.attn(ident), ids, steps, cap, s, scratch, out_ref, n_q, nullptr);
|
||||
k::kv_stream_resolve(m, slots.attn(m.page_table), host.p, fmt, ids, steps, n_q, cap, s, nullptr);
|
||||
k::qsa_decode_attn_batch(q, slots.attn(m.page_table), ids, steps, cap, s, scratch, out_str, n_q, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "batch");
|
||||
ck(cudaMemcpy(a.data(), out_ref, (size_t) n_q * NH * D * 4, cudaMemcpyDeviceToHost), "a");
|
||||
ck(cudaMemcpy(b2.data(), out_str, (size_t) n_q * NH * D * 4, cudaMemcpyDeviceToHost), "b");
|
||||
if (std::memcmp(a.data(), b2.data(), (size_t) n_q * NH * D * 4) != 0) {
|
||||
if (bad++ < 5) std::fprintf(stderr, " %s pos %lld n_q %d: streamed attention differs\n", name, (long long) pos, n_q);
|
||||
}
|
||||
// the map inverts itself
|
||||
ck(cudaMemcpy(pt.data(), m.page_table, n_blocks * 4, cudaMemcpyDeviceToHost), "pt");
|
||||
ck(cudaMemcpy(sb.data(), m.slot_block, n_slots * 4, cudaMemcpyDeviceToHost), "sb");
|
||||
int64_t resident = 0;
|
||||
for (int64_t bk = 0; bk < n_blocks; ++bk) {
|
||||
if (pt[bk] < -1 || pt[bk] >= n_slots || (pt[bk] >= 0 && sb[pt[bk]] != bk)) {
|
||||
if (bad++ < 5) std::fprintf(stderr, " map broken at block %lld (table %d)\n", (long long) bk, pt[bk]);
|
||||
break;
|
||||
}
|
||||
resident += pt[bk] >= 0;
|
||||
}
|
||||
for (int64_t sl = 0; sl < n_slots; ++sl)
|
||||
if (sb[sl] >= 0 && pt[sb[sl]] != sl) { if (bad++ < 5) std::fprintf(stderr, " slot %lld not in the table\n", (long long) sl); break; }
|
||||
++batches;
|
||||
}
|
||||
const k::KvStreamCounters c = k::kv_stream_counters(m);
|
||||
std::printf(" %s: %d batches, %llu block lookups, %llu misses (%.1f%% hit), overflow %d, %d failures\n",
|
||||
name, batches, (unsigned long long) c.lookups, (unsigned long long) c.misses,
|
||||
c.lookups ? 100.0 * (double) (c.lookups - c.misses) / (double) c.lookups : 0.0, (int) c.overflow, bad);
|
||||
if (c.overflow || c.calls != (uint64_t) batches || c.misses == 0 || c.misses >= c.lookups) ++bad;
|
||||
|
||||
// 4. a ring over the same host copy: blocks [b1 - R, b1) restored, read through `b % R`
|
||||
{
|
||||
const int64_t R = 1500, b1 = n_blocks, b0 = b1 - R;
|
||||
Pools ring;
|
||||
ring.alloc(R, s, fmt, false);
|
||||
int32_t* rt = dalloc<int32_t>(n_blocks);
|
||||
k::kv_ring_table(rt, n_blocks, R, nullptr);
|
||||
k::kv_ring_restore(ring.attn(rt), host.p, fmt, b0, b1, R, s, nullptr);
|
||||
const int64_t width = cap;
|
||||
std::vector<int32_t> hids((size_t) cap), hst = {(int32_t) (N - 1), (int32_t) N, (int32_t) (N / 4), (int32_t) width};
|
||||
for (int64_t i = 0; i < width; ++i) hids[i] = (int32_t) (N - width + i); // the window's last cells
|
||||
ck(cudaMemcpy(ids, hids.data(), hids.size() * 4, cudaMemcpyHostToDevice), "ids");
|
||||
ck(cudaMemcpy(steps, hst.data(), 16, cudaMemcpyHostToDevice), "steps");
|
||||
k::qsa_decode_attn_batch(q, ref.attn(ident), ids, steps, cap, s, scratch, out_ref, 1, nullptr);
|
||||
k::qsa_decode_attn_batch(q, ring.attn(rt), ids, steps, cap, s, scratch, out_str, 1, nullptr);
|
||||
ck(cudaDeviceSynchronize(), "ring");
|
||||
ck(cudaMemcpy(a.data(), out_ref, (size_t) NH * D * 4, cudaMemcpyDeviceToHost), "a");
|
||||
ck(cudaMemcpy(b2.data(), out_str, (size_t) NH * D * 4, cudaMemcpyDeviceToHost), "b");
|
||||
const bool ok = std::memcmp(a.data(), b2.data(), (size_t) NH * D * 4) == 0;
|
||||
std::printf(" %s ring restore: %s\n", name, ok ? "identical" : "DIFFERS");
|
||||
if (!ok) ++bad;
|
||||
}
|
||||
return bad == 0;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
std::printf("kv_stream_parity: streamed vs resident KV, bitwise\n");
|
||||
const bool a = run(k::kKvInt8), b = run(k::kKvF16), c = run(k::kKvQ4);
|
||||
if (!a || !b || !c) ++g_fail;
|
||||
std::printf(g_fail ? "FAIL\n" : "PASS\n");
|
||||
return g_fail ? 1 : 0;
|
||||
}
|
||||
@@ -164,15 +164,19 @@ bool PleTable::open(const std::string& gguf_path, std::string& err, const PleIoO
|
||||
// row. `GgufFile` parses the header, so `tensor_data` is already correct; this asserts the tensor
|
||||
// exactly fills the file from there, which is what makes the whole arrangement checkable rather than
|
||||
// assumed. A wrong data offset would leave a different remainder.
|
||||
// A shard may hold other tensors too (Swift 1.5's shard 1 holds layers 0-12 and the table): the table must
|
||||
// then fit inside the file at its own offset; alone in its shard (the original's shard 2) it fills it exactly.
|
||||
const uint64_t need = impl_->n_rows * (uint64_t) PLE_ROW_BYTES;
|
||||
const uint64_t have = impl_->file->file_size() - impl_->file->data_start();
|
||||
if (need != have) {
|
||||
const bool alone = impl_->file->tensors().size() == 1;
|
||||
if (alone ? need != have : t->offset + need > have) {
|
||||
char buf[256];
|
||||
std::snprintf(buf, sizeof buf,
|
||||
"PLE table size mismatch: %llu rows x %d B = %llu, but the file holds %llu from "
|
||||
"PLE table size mismatch: %llu rows x %d B = %llu at offset %llu, but the file holds %llu from "
|
||||
"data_start %llu",
|
||||
(unsigned long long) impl_->n_rows, PLE_ROW_BYTES, (unsigned long long) need,
|
||||
(unsigned long long) have, (unsigned long long) impl_->file->data_start());
|
||||
(unsigned long long) t->offset, (unsigned long long) have,
|
||||
(unsigned long long) impl_->file->data_start());
|
||||
err = buf;
|
||||
close();
|
||||
return false;
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
@@ -126,6 +127,139 @@ int run(const char* name, const std::vector<float>& logits, int n_tokens, const
|
||||
return bad;
|
||||
}
|
||||
|
||||
// The Philox draw, host side - a transcription of the kernel's `philox_uniform` so the SAMPLED pick (not
|
||||
// just the greedy argmax) can be pinned against a reference. `__umulhi(a, b)` is the high half of a 32x32
|
||||
// multiply, spelled `(uint32_t)(((uint64_t) a * b) >> 32)` here.
|
||||
struct PhiloxRound {
|
||||
uint32_t& c0; uint32_t& c1; uint32_t& c2; uint32_t& c3;
|
||||
void step(uint32_t k0, uint32_t k1) const {
|
||||
const uint32_t hi0 = (uint32_t) (((uint64_t) 0x9E3779B9u * c0) >> 32);
|
||||
const uint32_t hi1 = (uint32_t) (((uint64_t) 0xBB67AE85u * c2) >> 32);
|
||||
const uint32_t lo0 = 0x9E3779B9u * c0;
|
||||
const uint32_t lo1 = 0xBB67AE85u * c2;
|
||||
const uint32_t n0 = hi1 ^ c1 ^ k0;
|
||||
const uint32_t n1 = lo1;
|
||||
const uint32_t n2 = hi0 ^ c3 ^ k1;
|
||||
const uint32_t n3 = lo0;
|
||||
c0 = n0; c1 = n1; c2 = n2; c3 = n3;
|
||||
}
|
||||
};
|
||||
|
||||
float host_philox_uniform(uint64_t seed, uint64_t counter) {
|
||||
uint32_t c0 = (uint32_t) counter, c1 = (uint32_t) (counter >> 32);
|
||||
uint32_t c2 = (uint32_t) seed, c3 = (uint32_t) (seed >> 32);
|
||||
PhiloxRound r{c0, c1, c2, c3};
|
||||
for (int i = 0; i < 10; ++i) r.step((uint32_t) i, 0u);
|
||||
return (float) (c0 >> 8) * (1.0f / 16777216.0f);
|
||||
}
|
||||
|
||||
// The full SAMPLED chain, host side - the kernel's `sampler_kernel` in serial form: penalties on the raw
|
||||
// logits during the top_k selection (ties to the lowest index), the min_p prefix cut, top_p's cut in double,
|
||||
// then penalties AGAIN on the temperature-scaled survivors (docs/sampling.md's after-temperature pass), and
|
||||
// one Philox draw at (seed, counter + row).
|
||||
int sampled_reference(const std::vector<float>& l, const std::vector<int>& hist,
|
||||
const strata::kernels::SamplerParams& p, int row) {
|
||||
auto penal = [&](float logit, int count) {
|
||||
if (count <= 0) return logit;
|
||||
if (logit <= 0.0f) logit *= p.penalty_repeat; else logit /= p.penalty_repeat;
|
||||
logit -= (float) count * p.penalty_freq + (count > 0 ? 1.0f : 0.0f) * p.penalty_present;
|
||||
return logit;
|
||||
};
|
||||
auto count = [&](int v) { int c = 0; for (int h : hist) if (h == v) ++c; return c; };
|
||||
const int nv = (int) l.size();
|
||||
const int KMAX = 64;
|
||||
const int k = p.top_k > 0 ? (p.top_k < KMAX ? p.top_k : KMAX) : 0;
|
||||
std::vector<int> sel_ids;
|
||||
std::vector<float> sel_logit;
|
||||
std::vector<char> taken((size_t) nv, 0);
|
||||
for (int i = 0; i < k; ++i) {
|
||||
int best = -1; float bv = 0;
|
||||
for (int v = 0; v < nv; ++v) {
|
||||
if (taken[(size_t) v]) continue;
|
||||
const float s = penal(l[(size_t) v], count(v));
|
||||
if (best < 0 || s > bv) { best = v; bv = s; }
|
||||
}
|
||||
taken[(size_t) best] = 1;
|
||||
sel_ids.push_back(best); sel_logit.push_back(bv);
|
||||
}
|
||||
int n_minp = (int) sel_ids.size();
|
||||
if (p.min_p > 0.0f) {
|
||||
const float thresh = sel_logit[0] + std::log(p.min_p);
|
||||
for (int i = 0; i < (int) sel_ids.size(); ++i)
|
||||
if (sel_logit[(size_t) i] < thresh) { n_minp = i; break; }
|
||||
}
|
||||
int n_keep = n_minp;
|
||||
if (p.top_p < 1.0f) {
|
||||
double sum = 0.0;
|
||||
for (int i = 0; i < n_minp; ++i) sum += std::exp((double) sel_logit[(size_t) i] - (double) sel_logit[0]);
|
||||
double cum = 0.0;
|
||||
int cut = n_minp;
|
||||
for (int i = 0; i < n_minp; ++i) {
|
||||
cum += std::exp((double) sel_logit[(size_t) i] - (double) sel_logit[0]) / sum;
|
||||
if (cum >= (double) p.top_p) { cut = i + 1; break; }
|
||||
}
|
||||
if (cut < p.min_keep) cut = p.min_keep < n_minp ? p.min_keep : n_minp;
|
||||
n_keep = cut;
|
||||
}
|
||||
const float inv_t = p.temperature > 0.0f ? 1.0f / p.temperature : 0.0f;
|
||||
auto scaled = [&](int i) { return penal(sel_logit[(size_t) i] * inv_t, count(sel_ids[(size_t) i])); };
|
||||
float smx = scaled(0);
|
||||
for (int i = 1; i < n_keep; ++i) smx = std::fmax(smx, scaled(i));
|
||||
double sum = 0.0;
|
||||
for (int i = 0; i < n_keep; ++i) sum += std::exp((double) scaled(i) - (double) smx);
|
||||
const float u = host_philox_uniform(p.seed, p.counter + (uint64_t) row);
|
||||
double cum = 0.0;
|
||||
int pick = sel_ids[(size_t) (n_keep - 1)];
|
||||
for (int i = 0; i < n_keep; ++i) {
|
||||
cum += std::exp((double) scaled(i) - (double) smx) / sum;
|
||||
if ((double) u < cum) { pick = sel_ids[(size_t) i]; break; }
|
||||
}
|
||||
return pick;
|
||||
}
|
||||
|
||||
// Survivors after the min_p + top_p cuts, in the sampled chain - the quantity an order or a threshold
|
||||
// actually changes, used to assert a fixture can SEE the feature before asserting the kernel matches.
|
||||
int sampled_cut(const std::vector<float>& l, const std::vector<int>& hist, const strata::kernels::SamplerParams& p) {
|
||||
auto penal = [&](float logit, int count) {
|
||||
if (count <= 0) return logit;
|
||||
if (logit <= 0.0f) logit *= p.penalty_repeat; else logit /= p.penalty_repeat;
|
||||
logit -= (float) count * p.penalty_freq + (count > 0 ? 1.0f : 0.0f) * p.penalty_present;
|
||||
return logit;
|
||||
};
|
||||
auto count = [&](int v) { int c = 0; for (int h : hist) if (h == v) ++c; return c; };
|
||||
const int nv = (int) l.size();
|
||||
const int KMAX = 64;
|
||||
const int k = p.top_k > 0 ? (p.top_k < KMAX ? p.top_k : KMAX) : 0;
|
||||
std::vector<float> sel;
|
||||
std::vector<char> taken((size_t) nv, 0);
|
||||
for (int i = 0; i < k; ++i) {
|
||||
int best = -1; float bv = 0;
|
||||
for (int v = 0; v < nv; ++v) {
|
||||
if (taken[(size_t) v]) continue;
|
||||
const float s = penal(l[(size_t) v], count(v));
|
||||
if (best < 0 || s > bv) { best = v; bv = s; }
|
||||
}
|
||||
taken[(size_t) best] = 1; sel.push_back(bv);
|
||||
}
|
||||
int n_minp = (int) sel.size();
|
||||
if (p.min_p > 0.0f) {
|
||||
const float thresh = sel[0] + std::log(p.min_p);
|
||||
for (int i = 0; i < (int) sel.size(); ++i)
|
||||
if (sel[(size_t) i] < thresh) { n_minp = i; break; }
|
||||
}
|
||||
if (p.top_p >= 1.0f) return n_minp;
|
||||
double sum = 0.0;
|
||||
for (int i = 0; i < n_minp; ++i) sum += std::exp((double) sel[(size_t) i] - (double) sel[0]);
|
||||
double cum = 0.0;
|
||||
int cut = n_minp;
|
||||
for (int i = 0; i < n_minp; ++i) {
|
||||
cum += std::exp((double) sel[(size_t) i] - (double) sel[0]) / sum;
|
||||
if (cum >= (double) p.top_p) { cut = i + 1; break; }
|
||||
}
|
||||
if (cut < p.min_keep) cut = p.min_keep < n_minp ? p.min_keep : n_minp;
|
||||
return cut;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
@@ -326,6 +460,116 @@ int main(int argc, char** argv) {
|
||||
bad += run("T=1 greedy=true is the argmax", l, NT3, p2, want);
|
||||
}
|
||||
|
||||
// ---- fixture 6: PENALTIES IN THE SAMPLED CHAIN. Fixture 4 pins the greedy (argmax) path; the sampled
|
||||
// chain applies penalties a SECOND time - after the temperature scaling, on the survivors - so it gets its
|
||||
// own reference (the full chain with the host Philox) and its own observability check: with the penalties
|
||||
// on, the history row's favourite must LOSE a pick it would win penalty-free.
|
||||
{
|
||||
const int NV2 = 8, NT2 = 2;
|
||||
strata::kernels::SamplerParams p;
|
||||
p.top_k = 5; p.top_p = 0.9f; p.temperature = 0.8f; p.seed = 9; p.counter = 0;
|
||||
p.penalty_last_n = 4; p.penalty_repeat = 3.0f; p.penalty_freq = 0.2f; p.penalty_present = 0.6f;
|
||||
|
||||
std::vector<float> l((size_t) NV2 * NT2, -8.0f);
|
||||
std::vector<int> hist((size_t) NT2 * 4, -1);
|
||||
for (int t = 0; t < NT2; ++t) {
|
||||
float* row = l.data() + (size_t) t * NV2;
|
||||
row[0] = 9.0f; row[1] = 4.5f; row[2] = 4.4f; row[3] = 4.3f; // token 0 leads clean (9 vs 4.5)
|
||||
hist[(size_t) t * 4 + 0] = 0; // and falls to 2.2/2.0 penalised
|
||||
hist[(size_t) t * 4 + 1] = t == 1 ? 0 : -1; // (repeat 3, freq, presence)
|
||||
}
|
||||
std::vector<int> want((size_t) NT2), clean((size_t) NT2);
|
||||
strata::kernels::SamplerParams clean_p = p;
|
||||
clean_p.penalty_last_n = 0; clean_p.penalty_repeat = 1.0f;
|
||||
clean_p.penalty_freq = 0.0f; clean_p.penalty_present = 0.0f;
|
||||
for (int t = 0; t < NT2; ++t) {
|
||||
const std::vector<float> row(l.begin() + (size_t) t * NV2, l.begin() + (size_t) (t + 1) * NV2);
|
||||
const std::vector<int> h(hist.begin() + (size_t) t * 4, hist.begin() + (size_t) (t + 1) * 4);
|
||||
want[(size_t) t] = sampled_reference(row, h, p, t);
|
||||
clean[(size_t) t] = sampled_reference(row, h, clean_p, t);
|
||||
}
|
||||
const bool visible = want[0] != clean[0] || want[1] != clean[1];
|
||||
std::printf(" %-34s %s (penalised picks %d/%d, clean %d/%d)\n",
|
||||
"sampled penalties are observable", visible ? "yes" : "*** NO ***", want[0], want[1],
|
||||
clean[0], clean[1]);
|
||||
if (!visible) ++bad;
|
||||
else bad += run("sampled chain: penalties + top_k/p", l, NT2, p, want, hist, 4);
|
||||
}
|
||||
|
||||
// ---- fixture 7: MIN_P. The cut is a PREFIX of the descending top_k list (logit >= max + log(min_p)),
|
||||
// so the fixture asserts the survivor count moves with the threshold (the observability half) and that
|
||||
// the kernel's pick equals the reference's through the full sampled chain (the correctness half).
|
||||
{
|
||||
const int NV3 = 8, NT3 = 2;
|
||||
std::vector<float> l((size_t) NV3 * NT3, -8.0f);
|
||||
for (int t = 0; t < NT3; ++t) {
|
||||
float* row = l.data() + (size_t) t * NV3;
|
||||
row[0] = 4.0f; row[1] = 3.5f; row[2] = 3.2f; row[3] = 3.1f; // gaps keep the cut off the
|
||||
row[4] = 2.0f; // logf/rounding knife edge
|
||||
}
|
||||
strata::kernels::SamplerParams base;
|
||||
base.top_k = 6; base.top_p = 1.0f; base.temperature = 0.9f; base.seed = 77;
|
||||
|
||||
int c0 = 0, c05 = 0, c09 = 0;
|
||||
for (int t = 0; t < NT3; ++t) {
|
||||
const std::vector<float> row(l.begin() + (size_t) t * NV3, l.begin() + (size_t) (t + 1) * NV3);
|
||||
strata::kernels::SamplerParams q = base; q.min_p = 0.0f;
|
||||
c0 += sampled_cut(row, {}, q);
|
||||
q.min_p = 0.5f; c05 += sampled_cut(row, {}, q);
|
||||
q.min_p = 0.9f; c09 += sampled_cut(row, {}, q);
|
||||
}
|
||||
const bool visible = c0 > c05 && c05 > c09 && c09 >= NT3;
|
||||
std::printf(" %-34s %s (survivors: min_p 0 -> %d, 0.5 -> %d, 0.9 -> %d)\n",
|
||||
"min_p cut is observable", visible ? "yes" : "*** NO ***", c0, c05, c09);
|
||||
if (!visible) ++bad;
|
||||
|
||||
for (float mp : {0.0f, 0.5f, 0.9f}) {
|
||||
strata::kernels::SamplerParams q = base; q.min_p = mp;
|
||||
std::vector<int> want((size_t) NT3);
|
||||
for (int t = 0; t < NT3; ++t) {
|
||||
const std::vector<float> row(l.begin() + (size_t) t * NV3, l.begin() + (size_t) (t + 1) * NV3);
|
||||
want[(size_t) t] = sampled_reference(row, {}, q, t);
|
||||
}
|
||||
char name[64];
|
||||
std::snprintf(name, sizeof name, "sampled chain: min_p=%.1f", (double) mp);
|
||||
bad += run(name, l, NT3, q, want);
|
||||
}
|
||||
}
|
||||
|
||||
// ---- fixture 8: THE PENALTY WINDOW IS THE TAIL. With an 8-entry history and penalty_last_n = 4, only
|
||||
// the LAST four entries count: a token punished in the old half must come back to full strength, and one
|
||||
// punished in the tail half stays down. The reference counts the same tail; the observability check runs
|
||||
// the reference once more WITHOUT the clamp (counting all 8) and requires the picks to differ.
|
||||
{
|
||||
const int NV4 = 8;
|
||||
strata::kernels::SamplerParams p;
|
||||
p.top_k = 0; p.top_p = 1.0f; p.temperature = 1.0f; p.greedy = true;
|
||||
p.penalty_last_n = 4; p.penalty_repeat = 3.0f; p.penalty_freq = 0.3f; p.penalty_present = 0.5f;
|
||||
|
||||
std::vector<float> l((size_t) NV4, -8.0f);
|
||||
l[0] = 6.0f; l[3] = 6.5f; // token 0 leads clean; token 3 is the tail offender
|
||||
std::vector<int> hist = {0, 0, 0, 0, 3, 3, 3, 3}; // token 0 old (out), token 3 in the tail
|
||||
|
||||
auto pick_clamped = [&](bool clamp) {
|
||||
int best = 0; float bv = 0; bool first = true;
|
||||
for (int v = 0; v < NV4; ++v) {
|
||||
int c = 0;
|
||||
for (int i = 0; i < (clamp ? 4 : 8); ++i) if (hist[(size_t) (8 - (clamp ? 4 : 8) + i)] == v) ++c;
|
||||
float logit = l[(size_t) v];
|
||||
if (c > 0) { logit = logit <= 0.0f ? logit * p.penalty_repeat : logit / p.penalty_repeat;
|
||||
logit -= (float) c * p.penalty_freq + p.penalty_present; }
|
||||
if (first || logit > bv) { bv = logit; best = v; first = false; }
|
||||
}
|
||||
return best;
|
||||
};
|
||||
const int want = pick_clamped(true), unclamped = pick_clamped(false);
|
||||
const bool visible = want != unclamped;
|
||||
std::printf(" %-34s %s (clamped pick %d, full-history pick %d)\n",
|
||||
"penalty window clamp is observable", visible ? "yes" : "*** NO ***", want, unclamped);
|
||||
if (!visible) ++bad;
|
||||
else bad += run("penalty window: tail only", {l.begin(), l.end()}, 1, p, {want}, hist, 8);
|
||||
}
|
||||
|
||||
// A continuous stream and individual decode calls consume the same draw counters.
|
||||
{
|
||||
constexpr int count = 32, vocab = 16;
|
||||
|
||||
+34
-8
@@ -335,10 +335,12 @@ __global__ void gate_attn_kernel(const float* __restrict__ a, const float* __res
|
||||
o16[i] = hf(a[i] * (1.0f / (1.0f + expf(-qf[t * 24 * 512 + h * 512 + 256 + d]))));
|
||||
}
|
||||
|
||||
// one block per (token, kv head, 64-value group); 64 threads
|
||||
// one block per (token, kv head, 64-value group); 64 threads. KV streaming: the pool page only if the block is
|
||||
// resident (table >= 0), and the host copy and the prompt path's staging pool (both identity layout) when given.
|
||||
__global__ void kv_append_kernel(const float* __restrict__ K, const float* __restrict__ V, int64_t pos0,
|
||||
const int32_t* __restrict__ table, int64_t page_size, uint16_t* k_pool,
|
||||
uint16_t* v_pool, int8_t* k_q, int8_t* v_q, uint16_t* k_scale, uint16_t* v_scale) {
|
||||
uint16_t* v_pool, int8_t* k_q, int8_t* v_q, uint16_t* k_scale, uint16_t* v_scale,
|
||||
strata::kernels::KvHostPools host, strata::kernels::KvHostPools stage) {
|
||||
const int64_t t = blockIdx.x;
|
||||
const int kvh = blockIdx.y, g = blockIdx.z >> 1;
|
||||
const bool is_v = (blockIdx.z & 1) != 0;
|
||||
@@ -347,8 +349,12 @@ __global__ void kv_append_kernel(const float* __restrict__ K, const float* __res
|
||||
const int64_t pos = pos0 + t;
|
||||
const int64_t page = table[pos / page_size];
|
||||
const int64_t row = (page * 2 + kvh) * page_size + pos % page_size;
|
||||
const int64_t row_id = ((pos / page_size) * 2 + kvh) * page_size + pos % page_size;
|
||||
if (k_pool != nullptr) {
|
||||
(is_v ? v_pool : k_pool)[row * 256 + d] = hf(x);
|
||||
const uint16_t h = hf(x);
|
||||
if (page >= 0) (is_v ? v_pool : k_pool)[row * 256 + d] = h;
|
||||
if (host.k_pool != nullptr) (is_v ? host.v_pool : host.k_pool)[row_id * 256 + d] = h;
|
||||
if (stage.k_pool != nullptr) (is_v ? stage.v_pool : stage.k_pool)[row_id * 256 + d] = h;
|
||||
return;
|
||||
}
|
||||
float a = fabsf(x);
|
||||
@@ -361,13 +367,27 @@ __global__ void kv_append_kernel(const float* __restrict__ K, const float* __res
|
||||
const float sf = __half2float(__ushort_as_half(sb));
|
||||
int q = 0;
|
||||
if (sf > 0.0f) { q = __float2int_rn(x / sf); q = q < -127 ? -127 : (q > 127 ? 127 : q); }
|
||||
(is_v ? v_q : k_q)[row * 256 + d] = (int8_t) q;
|
||||
if (threadIdx.x == 0) (is_v ? v_scale : k_scale)[row * 4 + g] = sb;
|
||||
if (page >= 0) {
|
||||
(is_v ? v_q : k_q)[row * 256 + d] = (int8_t) q;
|
||||
if (threadIdx.x == 0) (is_v ? v_scale : k_scale)[row * 4 + g] = sb;
|
||||
}
|
||||
if (host.k_q != nullptr) {
|
||||
(is_v ? host.v_q : host.k_q)[row_id * 256 + d] = (int8_t) q;
|
||||
if (threadIdx.x == 0) (is_v ? host.v_scale : host.k_scale)[row_id * 4 + g] = sb;
|
||||
}
|
||||
if (stage.k_q != nullptr) {
|
||||
(is_v ? stage.v_q : stage.k_q)[row_id * 256 + d] = (int8_t) q;
|
||||
if (threadIdx.x == 0) (is_v ? stage.v_scale : stage.k_scale)[row_id * 4 + g] = sb;
|
||||
}
|
||||
}
|
||||
__global__ void to_f16_kernel(const float* __restrict__ x, uint16_t* __restrict__ y, int64_t n) {
|
||||
for (int64_t i = (int64_t) blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (int64_t) gridDim.x * blockDim.x)
|
||||
y[i] = hf(x[i]);
|
||||
}
|
||||
__global__ void round_f16_kernel(const float* __restrict__ x, float* __restrict__ y, int64_t n) {
|
||||
for (int64_t i = (int64_t) blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (int64_t) gridDim.x * blockDim.x)
|
||||
y[i] = __half2float(__float2half_rn(x[i]));
|
||||
}
|
||||
__global__ void to_bf16_kernel(const float* __restrict__ x, uint16_t* __restrict__ y, int64_t n) {
|
||||
for (int64_t i = (int64_t) blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (int64_t) gridDim.x * blockDim.x)
|
||||
y[i] = bf(x[i]);
|
||||
@@ -377,10 +397,11 @@ __global__ void to_bf16_kernel(const float* __restrict__ x, uint16_t* __restrict
|
||||
|
||||
void kv_append(const float* K, const float* V, int64_t T, int64_t pos0, const int32_t* page_table, int64_t page_size,
|
||||
uint16_t* k_pool, uint16_t* v_pool, int8_t* k_q, int8_t* v_q, uint16_t* k_scale, uint16_t* v_scale,
|
||||
void* stream) {
|
||||
void* stream, const strata::kernels::KvHostPools* host, const strata::kernels::KvHostPools* stage) {
|
||||
if (T <= 0) return;
|
||||
kv_append_kernel<<<dim3((unsigned) T, 2, 8), 64, 0, (cudaStream_t) stream>>>(K, V, pos0, page_table, page_size, k_pool,
|
||||
v_pool, k_q, v_q, k_scale, v_scale);
|
||||
kv_append_kernel<<<dim3((unsigned) T, 2, 8), 64, 0, (cudaStream_t) stream>>>(
|
||||
K, V, pos0, page_table, page_size, k_pool, v_pool, k_q, v_q, k_scale, v_scale,
|
||||
host ? *host : strata::kernels::KvHostPools{}, stage ? *stage : strata::kernels::KvHostPools{});
|
||||
check("kv_append");
|
||||
}
|
||||
void to_f16(const float* x, uint16_t* y, int64_t n, void* stream) {
|
||||
@@ -388,6 +409,11 @@ void to_f16(const float* x, uint16_t* y, int64_t n, void* stream) {
|
||||
to_f16_kernel<<<(unsigned) ((n + 255) / 256 < 4096 ? (n + 255) / 256 : 4096), 256, 0, (cudaStream_t) stream>>>(x, y, n);
|
||||
check("to_f16");
|
||||
}
|
||||
void round_f16(const float* x, float* y, int64_t n, void* stream) {
|
||||
if (n <= 0) return;
|
||||
round_f16_kernel<<<(unsigned) ((n + 255) / 256 < 4096 ? (n + 255) / 256 : 4096), 256, 0, (cudaStream_t) stream>>>(x, y, n);
|
||||
check("round_f16");
|
||||
}
|
||||
void to_bf16(const float* x, uint16_t* y, int64_t n, void* stream) {
|
||||
if (n <= 0) return;
|
||||
to_bf16_kernel<<<(unsigned) ((n + 255) / 256 < 4096 ? (n + 255) / 256 : 4096), 256, 0, (cudaStream_t) stream>>>(x, y, n);
|
||||
|
||||
+161
-6
@@ -9,6 +9,10 @@
|
||||
#include "strata/kernels/iq_kernels.hpp"
|
||||
#include "strata/kernels/cpu/expert_layout.hpp"
|
||||
#include "strata/kernels/qsa.hpp"
|
||||
#include "strata/kernels/kv_stream.hpp"
|
||||
#include "strata/kernels/cvec.hpp"
|
||||
#include "strata/kernels/kv_q4.hpp"
|
||||
#include "strata/core/layer.hpp"
|
||||
#include "strata/kernels/qsa_decode_attn.hpp"
|
||||
#include "strata/kernels/qsa_select.hpp"
|
||||
#include "strata/prefill/gemm.hpp"
|
||||
@@ -111,8 +115,48 @@ struct Prefill::Impl {
|
||||
std::vector<uint32_t> ple_rows;
|
||||
float* ple_norm = nullptr;
|
||||
PrefillStats* stats = nullptr;
|
||||
// KV streaming: one layer's whole K/V, staged from the host copy per layer and chunk (identity layout)
|
||||
strata::kernels::KvHostPools stage;
|
||||
int32_t* ident_table = nullptr;
|
||||
};
|
||||
|
||||
namespace {
|
||||
// the staging pool of a streamed session: every page of one layer (same sequence in init and bytes_needed)
|
||||
// STRATA_KV_STAGE_OWN (A/B only): the staging pool gets its own allocation instead of borrowed expert slots, so a
|
||||
// streamed run lends the prompt path exactly the slots a resident one does (a lent expert runs on the CPU, which
|
||||
// rounds differently: without this an A/B compares two expert placements as well as two KV placements)
|
||||
bool stage_own() { static const bool v = std::getenv("STRATA_KV_STAGE_OWN") != nullptr; return v; }
|
||||
void take_stage(Alloc& o_borrowed, const core::SessionState& ss, const strata::kernels::QsaShapes& s,
|
||||
strata::kernels::KvHostPools& st, bool& ok) {
|
||||
const core::QsaState& q0 = ss.qsa_states[0];
|
||||
if (q0.kv_mode != 1) return;
|
||||
if (stage_own() && o_borrowed.count_only) return;
|
||||
Alloc own;
|
||||
own.owned = o_borrowed.owned;
|
||||
Alloc& o = stage_own() ? own : o_borrowed;
|
||||
const size_t rows = (size_t) q0.n_pages * s.n_head_kv * s.page_size;
|
||||
if (q0.kv_q4) {
|
||||
st.k_q4 = o.take<uint8_t>(rows * strata::kernels::kv_q4_bytes_per_head((int) s.head_dim), ok);
|
||||
st.v_q4 = o.take<uint8_t>(rows * strata::kernels::kv_q4_bytes_per_head((int) s.head_dim), ok);
|
||||
} else if (q0.kv_int8) {
|
||||
st.k_q = o.take<int8_t>(rows * s.head_dim, ok);
|
||||
st.v_q = o.take<int8_t>(rows * s.head_dim, ok);
|
||||
st.k_scale = o.take<uint16_t>(rows * (s.head_dim / 64), ok);
|
||||
st.v_scale = o.take<uint16_t>(rows * (s.head_dim / 64), ok);
|
||||
} else {
|
||||
st.k_pool = o.take<uint16_t>(rows * s.head_dim, ok);
|
||||
st.v_pool = o.take<uint16_t>(rows * s.head_dim, ok);
|
||||
}
|
||||
}
|
||||
strata::kernels::QsaAttnPools pools_of(const strata::kernels::KvHostPools& h, const int32_t* table) {
|
||||
strata::kernels::QsaAttnPools p;
|
||||
p.k_pool = h.k_pool; p.v_pool = h.v_pool; p.k_q = h.k_q; p.v_q = h.v_q; p.k_scale = h.k_scale; p.v_scale = h.v_scale;
|
||||
p.k_q4 = h.k_q4; p.v_q4 = h.v_q4;
|
||||
p.page_table = table;
|
||||
return p;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
Prefill::Prefill() : impl_(new Impl) {}
|
||||
Prefill::~Prefill() {
|
||||
if (!impl_) return;
|
||||
@@ -189,6 +233,17 @@ bool Prefill::init(const core::WeightTable& wt, const core::ModelGeometry& g, co
|
||||
}
|
||||
m.ple_emb = o.take<float>(T * N, ok);
|
||||
m.ple_norm = o.take<float>((size_t) strata::kernels::NG_HC_DIM, ok);
|
||||
take_stage(o, ss, s, m.stage, ok);
|
||||
if (ok && m.stage.present()) {
|
||||
const int64_t pages = ss.qsa_states[0].n_pages;
|
||||
std::vector<int32_t> ident((size_t) pages);
|
||||
for (int64_t i = 0; i < pages; ++i) ident[(size_t) i] = (int32_t) i;
|
||||
if (cudaMalloc((void**) &m.ident_table, ident.size() * 4) != cudaSuccess ||
|
||||
cudaMemcpy(m.ident_table, ident.data(), ident.size() * 4, cudaMemcpyHostToDevice) != cudaSuccess)
|
||||
ok = false;
|
||||
else
|
||||
m.owned.push_back(m.ident_table);
|
||||
}
|
||||
m.ids_host.resize(T * K); m.slot_host.resize(T * K); m.src_host.resize(T * K); m.cnt.resize(NE); m.off.resize(NE + 1);
|
||||
m.ple_emb_host.resize(T * N); m.ple_rows.resize(T * strata::kernels::PLE_N_HEADS);
|
||||
if (!ok) { err = "prefill: device buffers for a chunk of " + std::to_string(chunk) + " tokens do not fit"; return false; }
|
||||
@@ -223,6 +278,8 @@ uint64_t Prefill::bytes_needed(const core::ModelGeometry& g, const core::Session
|
||||
for (int i = 0; i < STAGE; ++i) o.take<uint8_t>((size_t) MAXBLOB(), ok);
|
||||
f(T * N);
|
||||
f((size_t) strata::kernels::NG_HC_DIM);
|
||||
strata::kernels::KvHostPools stage;
|
||||
take_stage(o, ss, s, stage, ok);
|
||||
return o.used + (8u << 20); // alignment slack
|
||||
}
|
||||
|
||||
@@ -261,6 +318,8 @@ bool Prefill::run(const int64_t* tokens, int64_t n, int64_t pos0, std::string& e
|
||||
int32_t prev[2] = {ss.ple_prev[0], ss.ple_prev[1]};
|
||||
|
||||
for (int64_t c0 = 0; c0 < n; c0 += m.T) {
|
||||
if (should_stop && should_stop()) { err = "cancelled"; return false; }
|
||||
if (std::getenv("STRATA_TRACE")) { std::fprintf(stderr, "strata trace: prompt chunk %lld of %lld\n", (long long) c0, (long long) n); std::fflush(stderr); }
|
||||
const int64_t T = std::min(m.T, n - c0), p0 = pos0 + c0;
|
||||
++stats_.chunks;
|
||||
// ---- embeddings, broadcast to the four streams
|
||||
@@ -367,11 +426,27 @@ bool Prefill::run(const int64_t* tokens, int64_t n, int64_t pos0, std::string& e
|
||||
if (!bf16_proj(m.gemm, wiq, m.mixed_bf, m.q_idx, T, v.name("indexer.q_proj.weight"), err)) return false;
|
||||
rms_rows(m.Kc, (const float*) wkn->data, T * 2, 256, 256, EPS, m.cs);
|
||||
rope(m.Kc, T, 2, 256, 512, p0, (float) strata::kernels::qsa_freq_base(), m.cs);
|
||||
kv_append(m.Kc, m.Vc, T, p0, st.page_table, s.page_size, st.kv_int8 ? nullptr : st.k_pool,
|
||||
st.kv_int8 ? nullptr : st.v_pool, st.k_q, st.v_q, st.k_scale, st.v_scale, m.cs);
|
||||
// KV streaming: this layer's cells [0, p0) come in from the host copy to the staging pool, and the
|
||||
// chunk's cells go to the host copy, the staging pool, and the VRAM slots of resident blocks
|
||||
const bool staged = st.kv_mode == 1;
|
||||
if (staged)
|
||||
strata::kernels::kv_stage_from_host(pools_of(m.stage, m.ident_table), st.host,
|
||||
core::qsa_kv_format(st),
|
||||
(p0 + s.page_size - 1) / s.page_size, s, m.cs);
|
||||
if (st.kv_q4) { // Q4_0 KV (kv_q4.hpp): rotated K and V, the queries below too, the output back
|
||||
strata::kernels::fwht256_inplace_cuda(m.Kc, T * 2, m.cs);
|
||||
strata::kernels::fwht256_inplace_cuda(m.Vc, T * 2, m.cs);
|
||||
strata::kernels::kv_append_q4(st.k_q4, st.v_q4, st.page_table, p0, T, m.Kc, m.Vc, s, m.cs,
|
||||
&st.host, staged ? &m.stage : nullptr);
|
||||
} else {
|
||||
kv_append(m.Kc, m.Vc, T, p0, st.page_table, s.page_size, st.kv_int8 ? nullptr : st.k_pool,
|
||||
st.kv_int8 ? nullptr : st.v_pool, st.k_q, st.v_q, st.k_scale, st.v_scale, m.cs,
|
||||
&st.host, staged ? &m.stage : nullptr);
|
||||
}
|
||||
split_q(m.Qf, m.q, T, m.cs);
|
||||
rms_rows(m.q, (const float*) wqn->data, T * 24, 256, 256, EPS, m.cs);
|
||||
rope(m.q, T, 24, 256, 6144, p0, (float) strata::kernels::qsa_freq_base(), m.cs);
|
||||
if (st.kv_q4) strata::kernels::fwht256_inplace_cuda(m.q, T * 24, m.cs);
|
||||
rms_rows(m.q_idx, (const float*) wiqn->data, T * 4, 128, 128, EPS, m.cs);
|
||||
rope(m.q_idx, T, 4, 128, 512, p0, (float) strata::kernels::qsa_freq_base(), m.cs);
|
||||
// the indexer appends, token by token; then scores + selection for many queries at once:
|
||||
@@ -393,16 +468,80 @@ bool Prefill::run(const int64_t* tokens, int64_t n, int64_t pos0, std::string& e
|
||||
strata::kernels::qsa_block_topk(m.sel_scores, steps0, nb, m.max_blocks, m.cap, s,
|
||||
m.sel_ids + t0 * m.cap, m.cs);
|
||||
}
|
||||
strata::kernels::QsaAttnPools pools;
|
||||
pools.page_table = st.page_table;
|
||||
if (st.kv_int8) { pools.k_q = st.k_q; pools.v_q = st.v_q; pools.k_scale = st.k_scale; pools.v_scale = st.v_scale; }
|
||||
else { pools.k_pool = st.k_pool; pools.v_pool = st.v_pool; }
|
||||
// STRATA_IDX_FP16_CHECK: would FP16 pooled indexer keys select the same cells? (the KV-streaming
|
||||
// design's last question). Every query is selected again from the pooled keys and `dead` rounded
|
||||
// to fp16 (exactly what an fp16 store reads back); the agreement with the fp32 selection is
|
||||
// printed cumulatively after each chunk's last QSA layer. Debug: syncs per layer.
|
||||
if (static const bool f16chk = std::getenv("STRATA_IDX_FP16_CHECK") != nullptr; f16chk) {
|
||||
static float *pooled16 = nullptr, *dead16 = nullptr;
|
||||
static int32_t* ids16 = nullptr;
|
||||
static double shared = 0, cells = 0;
|
||||
static long long queries = 0, same = 0, sel_queries = 0;
|
||||
const int64_t rows = st.idx_pooled_rows;
|
||||
if (pooled16 == nullptr &&
|
||||
(cudaMalloc((void**) &pooled16, (size_t) rows * s.idx_dim * 4) != cudaSuccess ||
|
||||
cudaMalloc((void**) &dead16, (size_t) s.idx_dim * 4) != cudaSuccess ||
|
||||
cudaMalloc((void**) &ids16, (size_t) (m.T * m.cap) * 4) != cudaSuccess)) {
|
||||
err = "STRATA_IDX_FP16_CHECK: no room for its buffers";
|
||||
return false;
|
||||
}
|
||||
round_f16(st.idx_pooled, pooled16, rows * s.idx_dim, m.cs);
|
||||
round_f16(st.idx_dead, dead16, s.idx_dim, m.cs);
|
||||
for (int64_t t0 = 0; t0 < T; t0 += m.sel_batch) {
|
||||
const int64_t nb = std::min(m.sel_batch, T - t0);
|
||||
const int32_t* steps0 = m.steps_dev + t0 * strata::kernels::kStepCount;
|
||||
strata::kernels::qsa_block_scores(pooled16, dead16, m.q_idx + t0 * 512, steps0, nb,
|
||||
m.max_blocks, s, m.sel_scores, m.cs);
|
||||
strata::kernels::qsa_block_topk(m.sel_scores, steps0, nb, m.max_blocks, m.cap, s,
|
||||
ids16 + t0 * m.cap, m.cs);
|
||||
}
|
||||
std::vector<int32_t> a((size_t) (T * m.cap)), b((size_t) (T * m.cap));
|
||||
cudaMemcpyAsync(a.data(), m.sel_ids, a.size() * 4, cudaMemcpyDeviceToHost, m.cs);
|
||||
cudaMemcpyAsync(b.data(), ids16, b.size() * 4, cudaMemcpyDeviceToHost, m.cs);
|
||||
cudaStreamSynchronize(m.cs);
|
||||
for (int64_t t = 0; t < T; ++t) {
|
||||
const int64_t w = m.steps_host[(size_t) (t * strata::kernels::kStepCount + strata::kernels::kStepWidth)];
|
||||
const int32_t *x = a.data() + t * m.cap, *y = b.data() + t * m.cap;
|
||||
int64_t i = 0, j = 0, c = 0;
|
||||
while (i < w && j < w) {
|
||||
if (x[i] == y[j]) { ++c; ++i; ++j; } else if (x[i] < y[j]) ++i; else ++j;
|
||||
}
|
||||
++queries;
|
||||
same += c == w;
|
||||
if (p0 + t + 1 > m.cap) { ++sel_queries; shared += (double) c; cells += (double) w; }
|
||||
}
|
||||
if (qsa_index + 1 == g.n_qsa_layers())
|
||||
std::fprintf(stderr, "strata prefill: FP16 indexer keys: %lld of %lld selections identical; "
|
||||
"where the selection is sparse, %.4f%% of cells shared (%lld queries)\n",
|
||||
same, queries, cells > 0 ? 100.0 * shared / cells : 100.0, sel_queries);
|
||||
}
|
||||
// STRATA_QSA_DUMP=<file>: append every QSA layer's selected cells for the prompt's last
|
||||
// STRATA_QSA_DUMP_LAST (4096) positions - records of int32 {qsa layer, pos0, T, cap} + T*cap cells,
|
||||
// for tools/qsa_locality.py (how local the sparse attention's reads are: the KV-streaming question)
|
||||
if (static const char* dump = std::getenv("STRATA_QSA_DUMP"); dump != nullptr) {
|
||||
static const long long last = std::getenv("STRATA_QSA_DUMP_LAST")
|
||||
? std::atoll(std::getenv("STRATA_QSA_DUMP_LAST")) : 4096;
|
||||
if (p0 + T > pos0 + n - last) {
|
||||
std::vector<int32_t> h((size_t) (T * m.cap));
|
||||
cudaMemcpyAsync(h.data(), m.sel_ids, h.size() * 4, cudaMemcpyDeviceToHost, m.cs);
|
||||
cudaStreamSynchronize(m.cs);
|
||||
if (std::FILE* f = std::fopen(dump, "ab")) {
|
||||
const int32_t hdr[4] = {(int32_t) qsa_index, (int32_t) p0, (int32_t) T, (int32_t) m.cap};
|
||||
std::fwrite(hdr, 4, 4, f);
|
||||
std::fwrite(h.data(), 4, h.size(), f);
|
||||
std::fclose(f);
|
||||
}
|
||||
}
|
||||
}
|
||||
const strata::kernels::QsaAttnPools pools = staged ? pools_of(m.stage, m.ident_table)
|
||||
: core::qsa_attn_pools(st);
|
||||
for (int64_t t0 = 0; t0 < T; t0 += m.attn_batch) {
|
||||
const int64_t nb = std::min(m.attn_batch, T - t0);
|
||||
strata::kernels::qsa_decode_attn_batch(m.q + t0 * ZV, pools, m.sel_ids + t0 * m.cap,
|
||||
m.steps_dev + t0 * strata::kernels::kStepCount, m.cap, s,
|
||||
m.attn_scratch, m.attn + t0 * ZV, nb, m.cs);
|
||||
}
|
||||
if (st.kv_q4) strata::kernels::fwht256_inplace_cuda(m.attn, T * 24, m.cs);
|
||||
gate_attn(m.attn, m.Qf, m.attn_h, T, m.cs);
|
||||
if (!native_proj(m.gemm, wo, m.attn_h, m.bo, T, v.name("attn_output.weight"), err)) return false;
|
||||
++qsa_index;
|
||||
@@ -513,6 +652,8 @@ bool Prefill::run(const int64_t* tokens, int64_t n, int64_t pos0, std::string& e
|
||||
}
|
||||
// ---- the hyper-connection write of this half
|
||||
gr_write(m.R, m.bo, m.inj, HC, T, m.cs);
|
||||
if (half == 1 && strata::kernels::cvec().covers(l)) // --control-vector-scaled
|
||||
strata::kernels::cvec_apply(m.R, l, T, D, nullptr, 0, nullptr, 0, false, m.cs);
|
||||
}
|
||||
}
|
||||
stats_.tokens += T;
|
||||
@@ -531,6 +672,20 @@ bool Prefill::run(const int64_t* tokens, int64_t n, int64_t pos0, std::string& e
|
||||
return false;
|
||||
}
|
||||
stats_.ms_total += ms_since(t_start);
|
||||
if (std::getenv("STRATA_STATE_HASH_GDN") != nullptr) { // debug: the GDN states as the prompt path leaves them
|
||||
cudaStreamSynchronize(m.cs);
|
||||
std::vector<uint8_t> b((size_t) gdn_floats * 4);
|
||||
std::string line;
|
||||
char h[8];
|
||||
for (int64_t i = 0; i < g.n_gdn_layers(); ++i) {
|
||||
cudaMemcpy(b.data(), ss.gdn_state + (size_t) i * gdn_floats, b.size(), cudaMemcpyDeviceToHost);
|
||||
uint64_t x = 1469598103934665603ull;
|
||||
for (uint8_t c : b) x = (x ^ c) * 1099511628211ull;
|
||||
std::snprintf(h, sizeof(h), "%04llx ", (unsigned long long) (x & 0xffff));
|
||||
line += h;
|
||||
}
|
||||
std::fprintf(stderr, "strata prefill: GDN_HASH %s\n", line.c_str());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
+975
-82
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,101 @@
|
||||
// src/spec/draft_policy.cpp - see include/strata/spec/draft_policy.hpp.
|
||||
#include "strata/spec/draft_policy.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
namespace strata::spec {
|
||||
namespace {
|
||||
|
||||
// The shape of a round's cost by window size, relative to one token, used only for sizes not measured yet (the
|
||||
// measured round times replace it). Between the RTX 5070's measured curves: +10 ms per token with every missed expert
|
||||
// on the CPU (bench/results/2026-09-27-spec/window-cost), flatter with the default CPU/DMA split.
|
||||
constexpr double kShape[DraftPolicy::kMaxT + 1] = {0.0, 1.0, 1.35, 1.7, 2.05, 2.45, 2.85, 3.25, 3.6};
|
||||
constexpr double kCostAlpha = 0.1; // EMA weight of a new round time
|
||||
constexpr double kTokAlpha = 0.05; // EMA weight of a new MTP window outcome
|
||||
constexpr double kDecay = 0.97; // lookup counts: older windows fade
|
||||
// Before a bucket has data: the longer the match, the likelier its continuation (llama.cpp's lookup decoding gates
|
||||
// on the same thing); worth 4 observations, so a few real windows override it
|
||||
constexpr double kPriorQ[DraftPolicy::kBuckets] = {0.75, 0.88, 0.93, 0.96};
|
||||
constexpr double kPriorN = 4.0;
|
||||
constexpr int kProbes = 3; // a lookup window size is tried this often before its guessed cost can veto it
|
||||
|
||||
} // namespace
|
||||
|
||||
DraftPolicy::DraftPolicy(int max_t, double margin)
|
||||
: max_t_(std::clamp(max_t, 1, kMaxT)), margin_(margin) {}
|
||||
|
||||
int DraftPolicy::bucket(int match) {
|
||||
return match < 6 ? 0 : match < 12 ? 1 : match < 24 ? 2 : 3;
|
||||
}
|
||||
|
||||
double DraftPolicy::lookup_rate(int match) const {
|
||||
const int b = bucket(match);
|
||||
return (ok_[b] + kPriorN * kPriorQ[b]) / (ok_[b] + bad_[b] + kPriorN);
|
||||
}
|
||||
|
||||
double DraftPolicy::cost_ms(int t) const {
|
||||
t = std::clamp(t, 1, kMaxT);
|
||||
if (cost_n_[t] > 0) return cost_[t];
|
||||
// scale from the measured sizes, weighting each by how often it was seen
|
||||
double num = 0.0, den = 0.0;
|
||||
for (int u = 1; u <= kMaxT; ++u)
|
||||
if (cost_n_[u] > 0) {
|
||||
const double w = std::min(cost_n_[u], 20.0);
|
||||
num += w * cost_[u] * kShape[t] / kShape[u];
|
||||
den += w;
|
||||
}
|
||||
return den > 0 ? num / den : kShape[t];
|
||||
}
|
||||
|
||||
double DraftPolicy::mtp_tokens(int t) const {
|
||||
if (mtp_n_[t] > 0) return mtp_tok_[t];
|
||||
return 1.0 + 0.7 * (t - 1); // before any MTP window of this size: a typical acceptance
|
||||
}
|
||||
|
||||
DraftPolicy::Pick DraftPolicy::choose(int t_mtp, int lookup_k, int match) const {
|
||||
Pick p;
|
||||
p.t = std::clamp(t_mtp, 1, max_t_);
|
||||
if (lookup_k <= 0) return p;
|
||||
const double base = mtp_tokens(p.t) / cost_ms(p.t);
|
||||
const double q = lookup_rate(match);
|
||||
double e = 1.0, qi = 1.0, best = 0.0;
|
||||
int best_t = 0;
|
||||
for (int k = 1; k <= std::min(lookup_k, max_t_ - 1); ++k) {
|
||||
qi *= q;
|
||||
e += qi;
|
||||
const double r = e / cost_ms(k + 1);
|
||||
if (r > best) { best = r; best_t = k + 1; }
|
||||
}
|
||||
if (best_t > 0 && best > base * (1.0 + margin_)) {
|
||||
p.lookup = true;
|
||||
p.t = best_t;
|
||||
return p;
|
||||
}
|
||||
// a guessed cost can keep the policy from ever measuring a size: the first few times a confident lookup would
|
||||
// need a size not measured yet, it is tried (verification keeps the output; only the one round's speed is at stake)
|
||||
const int t_full = std::min(lookup_k, max_t_ - 1) + 1;
|
||||
if (t_full > p.t && cost_n_[t_full] < kProbes && q >= 0.85) {
|
||||
p.lookup = true;
|
||||
p.t = t_full;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
void DraftPolicy::observe(bool lookup, int t, int accepted, int match, double round_ms) {
|
||||
t = std::clamp(t, 1, kMaxT);
|
||||
if (round_ms > 0) {
|
||||
cost_[t] = cost_n_[t] > 0 ? (1.0 - kCostAlpha) * cost_[t] + kCostAlpha * round_ms : round_ms;
|
||||
cost_n_[t] += 1.0;
|
||||
}
|
||||
if (lookup) {
|
||||
const int b = bucket(match);
|
||||
ok_[b] = kDecay * ok_[b] + accepted;
|
||||
bad_[b] = kDecay * bad_[b] + (accepted < t - 1 ? 1.0 : 0.0);
|
||||
} else {
|
||||
const double got = accepted + 1.0;
|
||||
mtp_tok_[t] = mtp_n_[t] > 0 ? (1.0 - kTokAlpha) * mtp_tok_[t] + kTokAlpha * got : got;
|
||||
mtp_n_[t] += 1.0;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace strata::spec
|
||||
@@ -0,0 +1,63 @@
|
||||
// src/spec/draft_policy_test.cpp - DraftPolicy: when does a lookup window beat the MTP's?
|
||||
//
|
||||
// Simulated rounds with the costs measured on the RTX 5070 (window-cost: ~10 ms more per token) check that
|
||||
// 1. with no lookup proposal the MTP window is kept;
|
||||
// 2. lookup drafts that are mostly rejected stop being taken (their bucket's rate falls);
|
||||
// 3. lookup drafts that are always accepted are taken, and the window grows with them;
|
||||
// 4. match-length buckets learn separately (short matches failing does not stop long ones);
|
||||
// 5. the policy never proposes a window beyond its cap.
|
||||
#include "strata/spec/draft_policy.hpp"
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
using strata::spec::DraftPolicy;
|
||||
|
||||
namespace {
|
||||
int g_fail = 0;
|
||||
void check(bool ok, const char* what) {
|
||||
std::printf(" %-66s %s\n", what, ok ? "ok" : "FAIL");
|
||||
if (!ok) ++g_fail;
|
||||
}
|
||||
double cost(int t) { return 19.0 + 10.5 * (t - 1); } // ms per round, measured shape
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
std::printf("draft_policy_test\n");
|
||||
{
|
||||
DraftPolicy p(6);
|
||||
for (int i = 0; i < 50; ++i) p.observe(false, 4, 2, 0, cost(4)); // MTP windows of 4: 3 tokens each
|
||||
const DraftPolicy::Pick k = p.choose(4, 0, 0);
|
||||
check(!k.lookup && k.t == 4, "no proposal: the MTP window");
|
||||
}
|
||||
{
|
||||
DraftPolicy p(6);
|
||||
for (int i = 0; i < 50; ++i) p.observe(false, 4, 2, 0, cost(4));
|
||||
for (int t = 2; t <= 6; ++t) p.observe(false, t, 0, 0, cost(t));
|
||||
for (int i = 0; i < 40; ++i) p.observe(true, 6, 0, 4, cost(6)); // short matches, all rejected
|
||||
check(p.lookup_rate(4) < 0.15, "rejected short-match drafts: their rate falls below 0.15");
|
||||
check(!p.choose(4, 5, 4).lookup, "rejected short-match drafts: no longer taken");
|
||||
for (int i = 0; i < 40; ++i) p.observe(true, 6, 5, 30, cost(6)); // long matches, all accepted
|
||||
check(p.lookup_rate(30) > 0.9, "accepted long-match drafts: their rate rises above 0.9");
|
||||
const DraftPolicy::Pick k = p.choose(4, 5, 30);
|
||||
check(k.lookup && k.t == 6, "accepted long matches: the full lookup window is taken");
|
||||
check(!p.choose(4, 5, 4).lookup, "buckets are separate: short matches still not taken");
|
||||
check(p.choose(4, 20, 30).t <= 6, "never beyond the window cap");
|
||||
}
|
||||
{
|
||||
DraftPolicy p(8);
|
||||
for (int i = 0; i < 50; ++i) p.observe(false, 3, 2, 0, cost(3)); // a very good MTP: 3 of 3 tokens
|
||||
for (int t = 2; t <= 8; ++t) p.observe(false, t, t - 1, 0, cost(t));
|
||||
for (int i = 0; i < 40; ++i) p.observe(true, 4, 2, 8, cost(4)); // lookup at q ~ 0.67
|
||||
check(!p.choose(3, 7, 8).lookup, "a mediocre lookup does not replace a strong MTP window");
|
||||
}
|
||||
{
|
||||
DraftPolicy p(6);
|
||||
for (int i = 0; i < 50; ++i) p.observe(false, 4, 3, 0, cost(4)); // a near-perfect MTP, only size 4 seen
|
||||
const DraftPolicy::Pick k = p.choose(4, 5, 40);
|
||||
check(k.lookup && k.t == 6, "an unmeasured size is probed for a confident lookup");
|
||||
for (int i = 0; i < 3; ++i) p.observe(true, 6, 5, 40, 3.0 * cost(6)); // it turns out very expensive
|
||||
check(!p.choose(4, 5, 40).lookup, "after the probes, the measured cost decides");
|
||||
}
|
||||
std::printf(g_fail ? "FAIL\n" : "PASS\n");
|
||||
return g_fail ? 1 : 0;
|
||||
}
|
||||
+1
-1
@@ -14,7 +14,7 @@ ENGINE = Path(__file__).resolve().parents[1]
|
||||
|
||||
def gguf_py() -> str:
|
||||
cands = [os.environ.get("STRATA_GGUF_PY"), ENGINE / "third_party" / "llama.cpp" / "gguf-py",
|
||||
ENGINE.parents[1] / ".ref" / "llama.cpp" / "gguf-py"]
|
||||
ENGINE.parents[min(1, len(ENGINE.parents) - 1)] / ".ref" / "llama.cpp" / "gguf-py"] # the dev tree; a shallow install (G:\Strata) has no grandparent
|
||||
for c in cands:
|
||||
if c and (Path(c) / "gguf").is_dir():
|
||||
return str(c)
|
||||
|
||||
+66
-13
@@ -15,7 +15,12 @@ its GGUF form:
|
||||
With --base: the base (Q2_0) pack's dense.bin, hard-linked - the float tensors are
|
||||
byte-identical in all three model files (checked) - plus extra.bin for tensors that are
|
||||
float here but quantized in the base pack (blk.1.ple_key).
|
||||
tokenizer/ exported from the GGUF (tools/strata_tokenizer.py).
|
||||
tokenizer/ exported from the GGUF (tools/strata_tokenizer.py), with the model's chat template.
|
||||
|
||||
Split files: every shard of the model is read (<name>-0000N-of-0000M.gguf beside --gguf), so the layers may be
|
||||
split anyhow (Swift 1.5's GGUFs put layers 13-47 in shard 2 and the PLE table in shard 1). A layer whose experts
|
||||
are not in shard 1 names its shard in native_experts.txt (v3). Router tensors stored as F32 whose values are
|
||||
exactly BF16 (Swift 1.5) are written as BF16, the form the engine's router takes; anything else is refused.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
@@ -34,6 +39,33 @@ sys.path.insert(0, str(HERE))
|
||||
import gguf_reader as G # noqa: E402
|
||||
|
||||
FLOAT = {"BF16", "F32", "F16"}
|
||||
ROUTERS = ("ffn_gate_inp.weight", "ffn_gate_inp_shexp.weight")
|
||||
NOT_IN_PACK = {"per_layer_token_embd.weight"} # the 28.8 GB PLE table: read from its GGUF by the engine
|
||||
|
||||
|
||||
class Model:
|
||||
"""All shards of one model: name -> (GGUFFile, TensorInfo, memmap, shard path)."""
|
||||
|
||||
def __init__(self, first: pathlib.Path):
|
||||
import re
|
||||
m = re.search(r"-(\d{5})-of-(\d{5})\.gguf$", first.name)
|
||||
paths = [first]
|
||||
if m:
|
||||
total = int(m.group(2))
|
||||
paths = [first.with_name(first.name[:m.start()] + "-%05d-of-%05d.gguf" % (i, total))
|
||||
for i in range(1, total + 1)]
|
||||
paths = [p for p in paths if p.exists()]
|
||||
self.paths = paths
|
||||
self.where = {}
|
||||
for p in paths:
|
||||
g = G.GGUFFile(p)
|
||||
mm = np.memmap(p, dtype=np.uint8, mode="r")
|
||||
for t in g.tensors:
|
||||
self.where[t.name] = (g, t, mm, p)
|
||||
|
||||
def bytes(self, name) -> np.ndarray:
|
||||
g, t, mm, _ = self.where[name]
|
||||
return tensor_bytes(mm, g, t)
|
||||
ROLES = ("gate", "up", "down")
|
||||
N_EXPERT = 512
|
||||
ALIGN = 64
|
||||
@@ -59,13 +91,14 @@ def is_expert(name: str) -> bool:
|
||||
return name.startswith("blk.") and name.endswith(("_exps.weight",))
|
||||
|
||||
|
||||
def index_standalone(src, out, g, T, mm) -> int:
|
||||
"""Every non-expert tensor of shard 1: floats into dense.bin as stored, quantized ones native-only."""
|
||||
def index_standalone(src, out, model: Model) -> int:
|
||||
"""Every non-expert tensor of the model: floats into dense.bin as stored (exact-BF16 F32 routers as BF16),
|
||||
quantized ones native-only."""
|
||||
rows, at = [], 0
|
||||
served = 0
|
||||
with open(out / "dense.bin", "wb") as fo:
|
||||
for t in g.tensors:
|
||||
if is_expert(t.name):
|
||||
for name, (g, t, mm, _) in model.where.items():
|
||||
if is_expert(t.name) or t.name in NOT_IN_PACK:
|
||||
continue
|
||||
if len(t.shape) > 2:
|
||||
print("tensor %s has %d dimensions; the index holds two" % (t.name, len(t.shape)))
|
||||
@@ -75,6 +108,13 @@ def index_standalone(src, out, g, T, mm) -> int:
|
||||
if t.type_name in FLOAT:
|
||||
raw = tensor_bytes(mm, g, t).tobytes()
|
||||
kind = {"BF16": "4", "F16": "5", "F32": "2"}[t.type_name]
|
||||
if t.type_name == "F32" and t.name.endswith(ROUTERS):
|
||||
u = np.frombuffer(raw, dtype=np.uint32)
|
||||
if np.count_nonzero(u & 0xFFFF):
|
||||
print("router %s is F32 with values that are not BF16; the engine's router is BF16" % t.name)
|
||||
return 1
|
||||
raw = (u >> 16).astype(np.uint16).tobytes() # the exact BF16 values
|
||||
kind = "4"
|
||||
rows.append([t.name, "0", kind, str(at), str(len(raw)), "0", str(len(raw)), str(ne0), str(ne1),
|
||||
"0", "0", "1"] + ["0"] * 7)
|
||||
fo.write(raw)
|
||||
@@ -167,15 +207,21 @@ def main() -> int:
|
||||
out.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
g = G.GGUFFile(src)
|
||||
T = {t.name: t for t in g.tensors}
|
||||
mm = np.memmap(src, dtype=np.uint8, mode="r")
|
||||
model = Model(src)
|
||||
T = {n: w[1] for n, w in model.where.items()}
|
||||
if len(model.paths) > 1:
|
||||
print("model shards: " + ", ".join(p.name for p in model.paths))
|
||||
if a.base:
|
||||
rc = index_from_base(a, src, base, out, g, T, mm)
|
||||
if any(w[3] != src for w in model.where.values() if not w[1].name in NOT_IN_PACK):
|
||||
print("--base needs a model whose tensors are all in shard 1")
|
||||
return 1
|
||||
rc = index_from_base(a, src, base, out, g, {t.name: t for t in g.tensors}, mm)
|
||||
else:
|
||||
rc = index_standalone(src, out, g, T, mm)
|
||||
rc = index_standalone(src, out, model)
|
||||
if rc:
|
||||
return rc
|
||||
if not (out / "tokenizer" / "vocab.json").exists():
|
||||
if not (out / "tokenizer" / "vocab.json").exists() or not (out / "tokenizer" / "chat_template.jinja").exists():
|
||||
subprocess.run([sys.executable, str(HERE / "strata_tokenizer.py"), "--gguf", str(src), "--out", str(out)],
|
||||
check=True) # writes <out>/tokenizer/
|
||||
|
||||
@@ -192,10 +238,17 @@ def main() -> int:
|
||||
layout.append((l, ts[0].type_id, ts[2].type_id, offset, blob, ts))
|
||||
offset += blob * N_EXPERT
|
||||
with open(out / "native_experts.txt", "w", encoding="utf-8", newline="\n") as fo:
|
||||
fo.write("# strata native experts v2: layer gu_type d_type offset blob_bytes gate_off up_off down_off "
|
||||
"(n_expert %d, total %d; the last three are absolute offsets in %s)\n" % (N_EXPERT, offset, src.name))
|
||||
fo.write("# strata native experts v3: layer gu_type d_type offset blob_bytes gate_off up_off down_off [shard] "
|
||||
"(n_expert %d, total %d; absolute offsets in %s, or in the named shard beside it)\n"
|
||||
% (N_EXPERT, offset, src.name))
|
||||
for l, gt, dt, off, blob, ts in layout:
|
||||
fo.write("%d %d %d %d %d %d %d %d\n" % (l, gt, dt, off, blob, *[g.data_start + t.offset for t in ts]))
|
||||
ws = [model.where[t.name] for t in ts]
|
||||
if len({w[3] for w in ws}) != 1:
|
||||
print("layer %d: its gate/up/down tensors are in different shards" % l)
|
||||
return 1
|
||||
gg, shard = ws[0][0], ws[0][3]
|
||||
line = "%d %d %d %d %d %d %d %d" % (l, gt, dt, off, blob, *[gg.data_start + t.offset for t in ts])
|
||||
fo.write(line + ("" if shard == src else " " + shard.name) + "\n")
|
||||
if a.skip_experts or not a.experts_bin:
|
||||
if (out / "experts.bin").exists() and not a.experts_bin:
|
||||
print("note: %s/experts.bin exists; the engine reads it instead of the GGUF" % out)
|
||||
@@ -206,7 +259,7 @@ def main() -> int:
|
||||
return 0
|
||||
with open(path, "wb") as fo:
|
||||
for l, gt, dt, off, blob, ts in layout:
|
||||
parts = [tensor_bytes(mm, g, t).reshape(N_EXPERT, -1) for t in ts]
|
||||
parts = [model.bytes(t.name).reshape(N_EXPERT, -1) for t in ts]
|
||||
chunk = np.concatenate(parts, axis=1) # (512, blob): gate | up | down per expert
|
||||
assert chunk.shape == (N_EXPERT, blob)
|
||||
fo.write(chunk.tobytes())
|
||||
|
||||
@@ -19,7 +19,6 @@ from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
|
||||
STRATA = Path(__file__).resolve().parents[3]
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||
from _paths import add_gguf_py # noqa: E402
|
||||
add_gguf_py()
|
||||
|
||||
+1
-1
@@ -34,7 +34,7 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
|
||||
from gguf_reader import GGUFFile # noqa: E402
|
||||
|
||||
REPO = pathlib.Path(__file__).resolve().parents[1]
|
||||
STRATA = REPO.parents[1] # the development layout's default shards (setup.py always passes --gguf)
|
||||
STRATA = REPO.parents[min(1, len(REPO.parents) - 1)] # the dev layout's default shards (setup.py passes --gguf)
|
||||
SHARD1 = STRATA / "Q2_0" / "Qwen3.8-Flash-Next-GSQ-RCO-Q2_0-00001-of-00002.gguf"
|
||||
|
||||
H, FF, NE = 2560, 640, 512
|
||||
|
||||
@@ -41,7 +41,8 @@ from canonical_xcheck import (MAPPINGS, KV_IQ4NL, open_shard, # noqa
|
||||
|
||||
FORMAT_VERSION = 1
|
||||
ALIGN = 64 # every plane starts on a 64-byte boundary (P1.S7)
|
||||
STRATA = pathlib.Path(__file__).resolve().parents[3] # the development layout; build takes the shard from --gguf
|
||||
_HERE = pathlib.Path(__file__).resolve()
|
||||
STRATA = _HERE.parents[min(3, len(_HERE.parents) - 1)] # the development layout; build takes the shard from --gguf
|
||||
SHARD2 = STRATA / "Q2_0" / "Qwen3.8-Flash-Next-GSQ-RCO-Q2_0-00002-of-00002.gguf"
|
||||
|
||||
EXPERT_RE = ("ffn_gate_exps.weight", "ffn_up_exps.weight", "ffn_down_exps.weight")
|
||||
|
||||
@@ -230,6 +230,12 @@ def extract(gguf_path, out_dir) -> dict:
|
||||
sorted(tk.ranks.items(), key=lambda kv: kv[1])), encoding="utf-8")
|
||||
(out / "token_type.json").write_text(json.dumps(tk.token_types), encoding="utf-8")
|
||||
(out / "tokenizer.json").write_text(json.dumps(cfg, ensure_ascii=False, indent=1), encoding="utf-8")
|
||||
# the model's own chat template: fine-tunes change it (Swift 1.5 differs from Qwen3.8-Flash-Next's)
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
|
||||
from gguf_reader import GGUFFile
|
||||
tpl = GGUFFile(pathlib.Path(gguf_path)).metadata.get("tokenizer.chat_template")
|
||||
if tpl:
|
||||
(out / "chat_template.jinja").write_text(tpl, encoding="utf-8", newline="\n")
|
||||
return cfg
|
||||
|
||||
|
||||
|
||||
@@ -99,6 +99,30 @@ int main(int argc, char** argv) {
|
||||
if (gg) gguf_free(gg);
|
||||
}
|
||||
if (n_embd <= 0) { std::printf("ERR the vision encoder has no projection_dim\n"); std::fflush(stdout); return 1; }
|
||||
// Warm up at the LARGEST picture before READY: the encoder's GPU work buffers are allocated now, not at the first
|
||||
// real picture. The server starts this process before the engine, so the engine sizes its expert cache from
|
||||
// what is really left; allocating ~1 GB later, on a GPU the engine has filled, made Windows page GPU memory and
|
||||
// the engine crawl to a standstill. (A square image well above any cap; mtmd scales it to the token limit.)
|
||||
{
|
||||
const uint32_t side = 2048;
|
||||
std::vector<unsigned char> rgb((size_t) side * side * 3, 128);
|
||||
mtmd_bitmap* bm = mtmd_bitmap_init(side, side, rgb.data());
|
||||
mtmd_input_chunks* chunks = mtmd_input_chunks_init();
|
||||
const std::string marker = mtmd_default_marker();
|
||||
mtmd_input_text txt{marker.c_str(), marker.size(), false, true};
|
||||
const mtmd_bitmap* bms[1] = {bm};
|
||||
int warm_tokens = 0;
|
||||
if (bm && mtmd_tokenize(ctx, chunks, &txt, bms, 1) == 0) {
|
||||
for (size_t c = 0; c < mtmd_input_chunks_size(chunks); ++c) {
|
||||
const mtmd_input_chunk* ch = mtmd_input_chunks_get(chunks, c);
|
||||
if (mtmd_input_chunk_get_type(ch) == MTMD_INPUT_CHUNK_TYPE_IMAGE && mtmd_encode_chunk(ctx, ch) == 0)
|
||||
warm_tokens = (int) mtmd_input_chunk_get_n_tokens(ch);
|
||||
}
|
||||
}
|
||||
std::fprintf(stderr, "strata-vision: warmed up at %d image tokens\n", warm_tokens);
|
||||
mtmd_input_chunks_free(chunks);
|
||||
if (bm) mtmd_bitmap_free(bm);
|
||||
}
|
||||
std::printf("READY %d\n", n_embd);
|
||||
std::fflush(stdout);
|
||||
|
||||
|
||||
Reference in new issue
Block a user