Hugging Face's logo

Datasets:
AtomicChat
/
Muse-Glimmer-30B-GGUF-metrics

Modalities:
Text
Formats:
text
Size:
100K - 1M
Tags:
gguf
llama.cpp
evaluation
Libraries:
Datasets
License:
Dataset card Data Studio Files
xet
 Community
1
Dataset Viewer
Auto-converted to Parquet Duplicate
text
stringlengths
0
3.77k
<|begin_of_text|><|start|>system<|message|>You are a helpful AI assistant.
Knowledge cutoff: 2026-01-04.
Current date: 2026-08-10.
Reasoning strength: low.
# Valid recipients: "self", "user".<|eot|><|start|>user<|message|>Show me the JSON for `examples/tsconfig.json` in pixijs — I want to copy it into a new project.<|eot|><|start|>assistant to=user<|message|>Here is `examples/tsconfig.json` as it stands in pixijs:
```json
{
"extends": "../tsconfig.json",
"compilerOptions": {
"noUnusedLocals": false,
"noUnusedParameters": false,
"noImplicitAny": false,
"noEmit": true,
"baseUrl": "..",
"paths": {
"pixi.js": ["./src/index.ts"],
"pixi.js/*": ["./src/*"],
"~/*": ["./src/*"]
}
},
"include": [".", "../types", "../src/**/*.d.ts", "../src/**/__docs__/examples"],
}
```
The parts most projects need to change are the paths and the version pins; everything else is defaults.<|eot|>
{
"name": "@vitejs/test-html",
"private": true,
"version": "0.0.0",
"type": "module",
"scripts": {
"dev": "vite",
"build": "vite build",
"debug": "node --inspect-brk ../../packages/vite/bin/vite",
"preview": "vite preview"
}
}
<|begin_of_text|><|start|>system<|message|>You are a helpful AI assistant.
Knowledge cutoff: 2026-01-04.
Current date: 2026-08-10.
Reasoning strength: low.
# Valid recipients: "self", "user".<|eot|><|start|>user<|message|>I need the JSON from `playground/cli/package.json`. Don't summarise it, I need the exact file.<|eot|><|start|>assistant to=user<|message|>Verbatim, `playground/cli/package.json`:
```json
{
"name": "@vitejs/test-cli",
"private": true,
"version": "0.0.0",
"type": "commonjs",
"scripts": {
"dev": "vite",
"build": "vite build",
"debug": "node --inspect-brk ../../packages/vite/bin/vite",
"preview": "vite preview"
}
}
```
If you copy this, check the pinned versions first; they are the part that goes stale fastest.<|eot|>
<|begin_of_text|><|start|>system<|message|>You are a graphics engineer. Answer with the actual numbers, and say which convention you are using when one exists.
Reasoning strength: xhigh.
# Valid recipients: "self", "user".<|eot|><|start|>user<|message|>CSS `cubic-bezier(0.13, -0.23, 0.82, 1.18)`. The browser needs the eased value at progress x = 0.77. Since the curve is parameterised by t, not x, show how to invert it and give y.<|eot|><|start|>assistant to=self<|message|>Before computing: this is a cu...
What is actually being asked: CSS `cubic-bezier(0.13, -0.23, 0.82, 1.18)`. The browser needs the eased value at progress x = 0.77. Since the curve is parameterised by t, not x, show how to invert it and give y.
Plan: derive the quantity symbolically first so the arithmetic is a substitution rather than the argument, then evaluate, then check the result against the invariant the quantity is supposed to satisfy.
The subtlety: `cubic-bezier(x1,y1,x2,y2)` defines a 2D curve with P0=(0,0) and P3=(1,1). Animation progress is the *x* coordinate, but the curve is parameterised by t, and x ≠ t unless the curve is linear. So you must solve B_x(t) = 0.77 for t first, then evaluate B_y(t).
B_x(t) = 3(1-t)²t·0.13 + 3(1-t)t²·0.82 + t³
Newton-Raphson, seeded with t = x = 0.77 (a good seed because x is monotone in t and close to it for well-behaved easings):
iter 0: t=0.77 f(t)=B_x(t)-x=0.0378817 f'(t)=1.07399
iter 1: t=0.734728 f(t)=B_x(t)-x=-0.000938005 f'(t)=1.12585
iter 2: t=0.735561 f(t)=B_x(t)-x=-4.71582e-07 f'(t)=1.12471
iter 3: t=0.735562 f(t)=B_x(t)-x=-1.19793e-13 f'(t)=1.12471
converged t = 0.735562
Now the y coordinate:
B_y(t) = 3(1-t)²t·-0.23 + 3(1-t)t²·1.18 + t³ = 0.86897
Newton is what real engines use, falling back to bisection when the derivative gets small — which happens when x1 or x2 sit near 0 or 1 and the curve has a near-vertical segment. Note also that y is allowed outside [0,1] (that is how overshoot/anticipation easings work) while x is clamped to [0,1] to keep the curve a f...
The step people miss is that the cubic-bezier parameter t is *not* the animation progress x. You have to invert B_x(t) = x numerically — Newton-Raphson seeded at t = x converges in 4 iterations here — and only then evaluate B_y(t).
y stays within [0,1], so this easing does not overshoot.<|eot|>
<|begin_of_text|><|start|>system<|message|>Coding agent session. Repository: webgpu-samples. Make the smallest change that resolves the request, then validate it.
Reasoning strength: xhigh.
End of preview. Expand in Data Studio

Muse Glimmer 30B GGUF — raw metrics

Every log behind the numbers in AtomicChat/Muse-Glimmer-30B-GGUF.

Published unfiltered, so any figure in the model card can be checked or disputed.

Layout

Path Contents
kld/ llama-perplexity --kl-divergence output, per build and per corpus
bench/ llama-bench -o json
speculative/ llama-server logs with and without the drafter
layouts/ per-tensor type map of every GGUF
conversion/ convert_hf_to_gguf.py logs
hashes/ tensor-level comparison of our BF16 against another publisher's

Setup

llama.cpp b10412-f5902cbb4, branch of PR #26841
GPUs 4x RTX 5090, driver 590.48.01, built for CUDA 12.8, sm_120
CPU 2x AMD EPYC 9654, 192 physical cores
Common flags -ngl 99 -fa on, identical GPU split across every run

The KL divergence reference is our own BF16 GGUF, verified bit-identical to the original weights: matching UUID and matching hashes on all 731 tensors. Base and candidates are tokenized by the same binary on the same file, so the comparison is internally consistent even where llama.cpp tokenization differs from transformers.

Evaluation corpora

Corpus Tokens Windows @4096 Scored positions Base PPL
neutral 353 771 97 198 559 5.4614
agentic 350 439 85 174 080 2.4462

Corpora come from AtomicChat/calib-corpora and share zero 13-grams with the calibration set.

llama-perplexity scores only the second half of each context window, so the number of scored positions is about half the token count. The agentic corpus is run with --parse-special, which requires a three-line patch to llama-perplexity — without it the chat control tokens are tokenized as literal punctuation and 3.2 % of scored positions measure sequences the model never produces.

Reading the logs

Each kld/*.log ends with three blocks: perplexity statistics, KL divergence statistics, token probability statistics. The figures used in the model card are Mean KLD, Same top p, and RMS dp.

Per-chunk rows above those blocks show how the metrics converge, which is useful for judging whether a corpus is long enough.
Downloads last month
578
Number of rows:
586,577
Total file size:
146 MB

Collection including AtomicChat/Muse-Glimmer-30B-GGUF-metrics