Modelpublic

jepacpp/ijepa_vith14_1k-GGUF

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

0likes192downloads

Model Card

I-JEPA ViT-H/14 (IN1k) — GGUF for jepa.cpp

Meta's I-JEPA ViT-H/14 image encoder, self-supervised on ImageNet-1k, converted to GGUF for jepa.cpp — a ggml C/C++ engine that runs it on a plain CPU with no Python and no PyTorch. No CLS token: the feature is the mean over the patch tokens after the final LayerNorm.

631 M parameters; D = 1280, 32 layers, 16 heads, patch 14, 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/ijepa_vith14_1k-GGUF ijepa_vith14_1k-f16.gguf --local-dir models/gguf

# one image -> a pooled feature vector
build/jepa-embed -m ijepa_vith14_1k-f16.gguf -i photo.jpg --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
`ijepa_vith14_1k-f32.gguf`	2406.2 MiB	`28a0e36868c93111`	exact	cos mean 1.000000, worst 1.000000, `rel_max` 7.9e-05 ᵖ
`ijepa_vith14_1k-f16.gguf`	1206.2 MiB	`cf03c8701a4b86fe`	parity	cos mean 0.999984, worst 0.997583 ᵖ
`ijepa_vith14_1k-q8_0.gguf`	643.7 MiB	`7fc0a94e3239c59d`	parity	cos mean 0.987843, worst 0.432576 ᵖ
`ijepa_vith14_1k-q4_0.gguf`	343.7 MiB	`f9ba10bd73e82503`	advisory	cos mean 0.972290, worst 0.433550, `pooled_mean` 0.993563 ᵈ
`ijepa_vith14_1k-q4_k.gguf`	343.7 MiB	`bade3038d5eda1ed`	advisory	cos mean 0.979426, worst 0.525752, `pooled_mean` 0.995850 ᵈ

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

28a0e36868c93111cab371b1d35a033a304689d2c36e0ff5e434c9b714620083  ijepa_vith14_1k-f32.gguf
cf03c8701a4b86fe35dab5480c0c6ee06c9a9f5a93c74a2c2da55b0862f73ad8  ijepa_vith14_1k-f16.gguf
7fc0a94e3239c59d5affa3532b3c6b4303e06ad0ccebc2d55f13917ada62cf68  ijepa_vith14_1k-q8_0.gguf
f9ba10bd73e82503d435a6cf247bf522258cf6a364e78f72cffb9f578dd1831c  ijepa_vith14_1k-q4_0.gguf
bade3038d5eda1ed9595577ec25daaefc94a00cde1d37a202bbd817157272159  ijepa_vith14_1k-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 ijepa_vith14_1k-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.

Imagenette k-NN — 3925 queries against a gallery of 2000 (train2000), the frozen mean feature, k = 20 cosine vote. Nothing is trained.

backend	dtype	k-NN top-1 %	centroid top-1 %	agreement with PyTorch %	mean feature cosine
pytorch	f32	95.36	92.25	—	1
jepa.cpp	f16	95.31	92.25	99.82	0.999944
jepa.cpp	q8_0	95.31	92.31	99.75	0.999774
jepa.cpp	q4_k	95.08	92.25	99.11	0.995049

Speed — the encoder graph at f16 on 32 threads (AMD Ryzen Threadripper PRO 7995WX 96-Cores): 147 ms per image against PyTorch's 250 ms. The same shape on NVIDIA RTX 4500 Ada Generation: 15.5 ms. Peak RSS at f16: 1230 MiB.

A small fraction of this model's tokens fall well below the pooled cosine at q80 — the low-variance tokens that the final LayerNorm amplifies — while every pooled feature stays close to 1. Use q80 and below for pooled features and retrieval, f16 or f32 for dense per-token work; the token-level analysis is in quantization.

Source, licence and attribution

Converted from `facebook/ijepa_vith14_1k`.

CC BY-NC 4.0 — non-commercial use only. The source checkpoint is published by Meta AI (FAIR) under Attribution-NonCommercial 4.0 International: license: cc-by-nc-4.0 on the model card, and the full CC text as LICENSE in facebookresearch/ijepa. 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 Meta, and are marked as modified. Cite the I-JEPA paper (Assran et al., 2023).

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