---

license: cc-by-nc-4.0

base_model: galilai-group/LeVJEPA-VideoMix-Large

library_name: jepa.cpp

tags:

- jepa

- ggml

- gguf

- jepa.cpp

- levjepa

- video

- video-feature-extraction

---

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

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 ᵖ |

_{ᵖ 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.}

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:

scripts/download_models.sh --convert levjepa
python scripts/convert.py --family levjepa --src models/galilai-group/LeVJEPA-VideoMix-Large \
                          --out models/gguf/levjepa-vitl16-f16.gguf --ftype f16
#   ... and again with --ftype f32 --out models/gguf/levjepa-vitl16-f32.gguf for the f32 file

for q in q8_0 q4_0 q4_k; do
  build/jepa-quantize models/gguf/levjepa-vitl16-f32.gguf \
      models/gguf/levjepa-vitl16-$q.gguf $q -t 32
done

jepa-quantize re-types only the 2-D attention / FFN / projection / classifier matrices; patch

embeddings, position tables, norms and biases keep the source type. The rules are in

docs/gguf-schema.md.

Links

• Code: <https://github.com/aselimc/jepa.cpp>
• Documentation: <https://aselimc.github.io/jepa.cpp/>
• Parity fixtures: <https://huggingface.co/datasets/jepacpp/jepa.cpp-fixtures>
• All jepa.cpp GGUFs: <https://huggingface.co/jepacpp>