Modelpublic

jepacpp/levjepa-vitl16-GGUF

sourceHugging Facecc-by-nc-4.0updated 22d agoView on Hugging Face

0likes233downloads

Model Card

LeVJEPA ViT-L/16 (VideoMix) — GGUF for jepa.cpp

The community LeVJEPA ViT-L/16 video encoder, trained from scratch on VideoMix (Kinetics-710, SSv2, Walking Tours, PE-Video), converted to GGUF for jepa.cpp — a ggml C/C++ engine that runs it on a plain CPU with no Python and no PyTorch. Tubelet 1 and a block-causal attention mask — bidirectional inside a frame, causal across frames, with the CLS token a read-only sink. The feature is that CLS token.

303 M parameters; D = 1024, 24 layers, 16 heads, patch 16, 224x224. Everything the engine needs — dimensions, positional scheme, preprocessing recipe, and class labels where there are any — travels inside the file, so inference needs one binary and one GGUF and nothing else.

Run it

bash

git clone --recursive https://github.com/aselimc/jepa.cpp && cd jepa.cpp
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release && cmake --build build -j
hf download jepacpp/levjepa-vitl16-GGUF levjepa-vitl16-f16.gguf --local-dir models/gguf

# a clip -> a CLS feature (a still image is repeated to the model's frame count, as its card does)
build/jepa-embed -m levjepa-vitl16-f16.gguf --frames-npy clip.npy --pool cls -t 32 -o feat.npy
build/jepa-embed -m levjepa-vitl16-f16.gguf -i photo.jpg          --pool cls -t 32

--pool selects mean, cls, lewm or none (the full token map); -o writes a .npy. scripts/download_models.sh fetches whole sets at once. The C API is one header, `include/jepa.h` — full reference on the C API page.

Files

file	size	sha256 (first 16)	tier	measured against the PyTorch reference
`levjepa-vitl16-f32.gguf`	1156.3 MiB	`e9a7ff2c7702002e`	exact	cos mean 1.000000, median 1.000000, worst 1.000000, `pooled_mean` 1.000000, `cls` 1.000000, `rel_max` 8.3e-06 ᵖ
`levjepa-vitl16-f16.gguf`	578.8 MiB	`ce84eff282f5bfe0`	parity	cos mean 0.999998, median 0.999999, worst 0.999820, `pooled_mean` 1.000000, `cls` 1.000000 ᵖ
`levjepa-vitl16-q8_0.gguf`	310.3 MiB	`aea7f01a26a5f514`	parity	cos mean 0.999789, median 0.999937, worst 0.991409, `pooled_mean` 0.999997, `cls` 0.999996 ᵖ
`levjepa-vitl16-q4_0.gguf`	166.3 MiB	`f9115e20845f7b52`	advisory	cos mean 0.997971, median 0.998157, worst 0.983584, `pooled_mean` 0.999716, `cls` 0.999612 ᵖ
`levjepa-vitl16-q4_k.gguf`	166.3 MiB	`765ba4f1a7c77d05`	advisory	cos mean 0.997031, median 0.997502, worst 0.962741, `pooled_mean` 0.999219, `cls` 0.999457 ᵖ

<sub>ᵖ tests/test-parity on the CPU backend, stored reference input, 32 threads, worst sample — docs/parity.md. ᵈ scripts/gguf_dequant_selftest.py: the dequantized weights through the numpy reference graph at f32 activations, so the figure is the weight error alone — docs/quantization.md. cos mean is the mean per-token cosine of last_hidden_state, worst its single worst token.</sub>

Tiers. exact — reproduces the PyTorch reference to the printed precision on the CPU. parity — passes its family's test-parity thresholds. advisory — below 8 bits per weight, which is not a parity configuration: the results are reported, only the derived tensors and the top-1 are gated. Which file to ship: Accuracy → which dtype.

Full checksums:

e9a7ff2c7702002e9c3c0c7f9e52cc7dd7e7833dd656910c6b23a26d4e4765d2  levjepa-vitl16-f32.gguf
ce84eff282f5bfe06cdd5c45b91f7864ca86576200ee63821eb7fd34ccbe7198  levjepa-vitl16-f16.gguf
aea7f01a26a5f5142ece1130cf7693edb5eebc76d9f5e0f947c8f66e771c6cf8  levjepa-vitl16-q8_0.gguf
f9115e20845f7b52fa5dbede4143af854a2d378319dba6d29ebd8098cb7198c2  levjepa-vitl16-q4_0.gguf
765ba4f1a7c77d05b6398737d82fada94624f6868c5aca3edb3d7a6dcd6324d3  levjepa-vitl16-q4_k.gguf

Verify a download with sha256sum -c. The other types jepa-quantize can produce (q4_1, q5_0, q5_1, q5_k, q6_k, measured in quantization) are not published here; make them locally with build/jepa-quantize levjepa-vitl16-f16.gguf out.gguf q6_k -t 32.

Measured

Every figure below is read from a committed artifact of jepa.cpp `00bfd4e` by scripts/hf_publish.py — parity, quantization, accuracy, performance and tests/results/*.json.

UCF-101 k-NN — 10 classes, 105 query clips (val+test) against a gallery of 300, 16 frames per clip, k = 20 cosine vote over frozen features. Nothing is trained.

backend	dtype	k-NN top-1 %	centroid top-1 %	k-NN agreement %	centroid agreement %	feature cosine
pytorch	f32	81.90	80.95	—	—	—
jepa.cpp	f32	81.90	80.95	100.00	100.00	1.000000
jepa.cpp	f16	81.90	80.95	100.00	100.00	1.000000
jepa.cpp	q8_0	81.90	80.95	100.00	100.00	0.999995

Speed — the encoder graph at f16 on 32 threads (AMD Ryzen Threadripper PRO 7995WX 96-Cores): 1496 ms per 16-frame clip against PyTorch's 1752 ms. The same shape on NVIDIA RTX 4500 Ada Generation: 87.6 ms. Peak RSS at f16: 779 MiB.

No low-cosine token tail. Where the V-JEPA 2 ViT-L encoders drop individual tokens badly at f16, not one of this model's tokens does on any fixture — its reference row norms sit in a narrow band, so the F16 activation rounding has no degenerate low-norm cluster to amplify. Its rows are all a multiple of the K-quant block, so the K-quants never fall back.

Source, licence and attribution

Converted from `galilai-group/LeVJEPA-VideoMix-Large`.

CC BY-NC 4.0 — non-commercial use only. The source checkpoint is published by galilai-group under Attribution-NonCommercial 4.0 International: license: cc-by-nc-4.0 in the model card's metadata, the repository's only licence statement (it ships no LICENSE file). The weights were trained from scratch, so the restriction is the publisher's own choice rather than inherited. These GGUF files are Adapted Material — the same weights re-serialised into the GGUF container, quantized where the file name says so — so they carry the same licence, credit galilai-group, and are marked as modified.

The licence travels inside every GGUF as general.license and the origin as general.source_url; build/jepa-info <file> --kv prints them. jepa.cpp's own code is MIT.

Conversion

Produced by jepa.cpp `00bfd4e`: