---

license: mit

base_model: facebook/vjepa2-vitl-fpc64-256

library_name: jepa.cpp

tags:

- jepa

- ggml

- gguf

- jepa.cpp

- v-jepa

- v-jepa-2

- video

- video-feature-extraction

---

V-JEPA 2 ViT-L/16 (fpc64, 256) — GGUF for jepa.cpp

Meta's V-JEPA 2 ViT-L/16 video encoder with its masked latent predictor, converted to GGUF for

jepa.cpp — a ggml C/C++ engine that runs it on a plain CPU with no Python and no PyTorch.

Tubelets of two frames and 3-D RoPE in Meta's tiled layout; a whole clip goes through one graph.

326 M parameters; D = 1024, 24 layers, 16 heads, patch 16, tubelet 2, 256x256. 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/vjepa2-vitl-fpc64-256-GGUF vjepa2-vitl-fpc64-256-f16.gguf --local-dir models/gguf

# a clip (THWC uint8 .npy, written by scripts/video_frames.py) -> a pooled feature
build/jepa-embed -m vjepa2-vitl-fpc64-256-f16.gguf --frames-npy clip.npy --pool mean -t 32 -o feat.npy

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

|---|---|---|---|---|

| vjepa2-vitl-fpc64-256-f32.gguf | 1243.5 MiB | 3cfa5734f4614087 | exact | cos mean 1.000000, median 1.000000, worst 0.999999, pooled_mean 1.000000, rel_max 7.5e-04 ᵖ |

| vjepa2-vitl-fpc64-256-f16.gguf | 622.5 MiB | 7ee7643dd2ef8dce | parity | cos mean 0.997144, median 0.999897, worst 0.5088, pooled_mean 0.999991 ᵖ |

| vjepa2-vitl-fpc64-256-q8_0.gguf | 332.8 MiB | 2503b98662e7867a | parity | cos mean 0.966128, median 0.996770, worst 0.2305, pooled_mean 0.999876 ᵖ |

| vjepa2-vitl-fpc64-256-q4_0.gguf | 178.3 MiB | 2d76e582432dae2f | advisory | cos mean 0.915000, worst 0.200962, pooled_mean 0.994207 ᵈ |

| vjepa2-vitl-fpc64-256-q4_k.gguf | 178.3 MiB | c6c402e55e5508a0 | advisory | cos mean 0.931075, worst 0.220083, pooled_mean 0.996089 ᵈ |

_{ᵖ 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:

3cfa5734f46140876aa4a49e914bf9f050e481253c4362e57ef4529a0820bd4d  vjepa2-vitl-fpc64-256-f32.gguf
7ee7643dd2ef8dcee6fddf8c5a13f9115c134030e724caec8993144b5acd00ed  vjepa2-vitl-fpc64-256-f16.gguf
2503b98662e7867afcf6b5ada294c76c1f8f8d72900b0a2ba5ae4ce9a5b48169  vjepa2-vitl-fpc64-256-q8_0.gguf
2d76e582432dae2f1b71a5a7f271e058d3b9d98094dc6968ffffa6f82a918600  vjepa2-vitl-fpc64-256-q4_0.gguf
c6c402e55e5508a062c697703c4660b0017da17432b2ff66a287f6f071cb219a  vjepa2-vitl-fpc64-256-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 vjepa2-vitl-fpc64-256-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 | 88.57 | 95.24 | — | — | — |

| jepa.cpp | f16 | 89.52 | 95.24 | 99.05 | 100.00 | 0.999996 |

| jepa.cpp | q8_0 | 89.52 | 95.24 | 99.05 | 100.00 | 0.999886 |

Speed — the encoder graph at f16 on 32 threads (AMD Ryzen Threadripper PRO 7995WX 96-Cores): 821 ms per 16-frame clip; 6388 ms per 64-frame clip. The same shape on NVIDIA RTX 4500 Ada Generation: 46.5 ms. Peak RSS at f16: 1034 MiB.

Use f32 if you consume individual tokens of this model. Its activation range contains a degenerate

low-norm token cluster that the F16 activation rounding inside ggml's mul_mat collapses — a property

of the checkpoint, reproduced in numpy, not an engine defect, and the reason its f16 and q8_0 worst-token

columns above read so much lower than its pooled ones. Everything pooled is unaffected. The mechanism is

worked through in accuracy.

Source, licence and attribution

Converted from facebook/vjepa2-vitl-fpc64-256.

MIT. The source checkpoint is published by Meta AI (FAIR): license: mit on the model card and

LICENSE in facebookresearch/vjepa2

(Copyright (c) Meta Platforms, Inc. and affiliates). There is no separate weights licence, no gating and

no acceptable-use policy. These GGUF files are the same weights re-serialised into the GGUF container,

quantized where the file name says so. Cite the V-JEPA 2 paper.

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 vjepa2
python scripts/convert.py --family vjepa2 --src models/facebook/vjepa2-vitl-fpc64-256 --ftype f16
#   ... and again with --ftype f32 for the f32 file

for q in q8_0 q4_0 q4_k; do
  build/jepa-quantize models/gguf/vjepa2-vitl-fpc64-256-f16.gguf \
      models/gguf/vjepa2-vitl-fpc64-256-$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>