LeVJEPA 1.5 Large

LeVJEPA 1.5 Large

Encodes video clips and single images into feature vectors, trained by self-supervised learning on about 5,300 video hours. A video encoder for researchers, under a non-commercial license.

Made by galilai-group on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: LeVJEPA 1.5 Large is a video encoder trained without labels. It turns a short clip, or one image, into feature vectors that other models can build on. Its mean score over 22 image and video datasets is 78.76%. Training used roughly 5,300 distinct hours of video and 151 exaflops.

Who it suits: It suits researchers who study video representation learning and want an encoder trained on far less data than earlier ones. The license is non-commercial.

Title: Who runs it
Industry | Who uses it | How they use it | Example
Research | Representation learning researchers | Probe the frozen encoder on image and video datasets | Reproduce the card's attentive probing results
Software | Computer vision developers | Extract clip features for a downstream classifier | Feed clip features into a small classifier
Medical imaging | Teams studying medical image sets | Test the encoder on sets such as the MNIST-style medical ones | Check scores on BloodMNIST or DermaMNIST

If you need a model for a commercial product, you can skip it.

Where to use it:

• Python with PyTorch and the transformers library, on Windows, macOS or Linux
• The LeVJEPA code repository, which loads the same weights without transformers
• Research notebooks, where the repository includes a patch feature visualizer

Title: Jobs it does
Use case | Who | What they get back
Clip features | Researchers | A 1024-number summary vector per clip
Per-frame patch features | Vision developers | Patch tokens for each of the 16 frames
Image features | Developers | A vector for a single image, repeated along the time axis

How to set it up:

• Python with PyTorch and transformers
• Clips of 16 frames at 224 by 224 pixels, normalized with the ImageNet mean and standard deviation
• Permission to run the model's own code, since trust_remote_code must be on

1. Install PyTorch and transformers.
2. Optionally download the model files by hand.
3. Load the model with AutoModel and run a clip through it.

pip install -U huggingface_hub
hf download galilai-group/LeVJEPA-1.5-Large

How to use it: Pass a tensor shaped batch, channels, time, height, width. The card samples clips at about 7.5 frames per second, so 16 frames cover about 2 s. The result starts with the [cls] token, then lists the patch tokens for each frame in turn.

import torch
from transformers import AutoModel

model = AutoModel.from_pretrained("galilai-group/LeVJEPA-1.5-Large", trust_remote_code=True).eval()

video = torch.randn(1, 3, 16, 224, 224)   # (B, C, T, H, W), ImageNet-normalized
with torch.no_grad():
    out = model(pixel_values=video)

out.last_hidden_state   # (1, 3137, 1024): [cls] + 16 * 14 * 14 patch tokens, in (frame, row, column) order
out["pooler_output"]    # (1, 1024): the [cls] token

Title: What to know about the call
Tool | What it does
last_hidden_state | Holds the [cls] token and the patch tokens of every frame
pooler_output | Gives the [cls] token alone as a 1024-number vector
trust_remote_code | Must be on, because the modeling code ships with the weights
attn_mode | Leave it at block_causal, since full attention returns worse features

Example: You pass one clip of 16 frames at 224 by 224, about 2 s of video. The model returns a 1024-number vector for the whole clip and one patch token per image region per frame. For a single image, you repeat it 16 times along the time axis first.

For newcomers and experts: If you are new, this model does not label a video for you. It turns a clip into numbers that describe it, and other tools use those numbers. The first small thing to try is the sample code with random numbers in place of a real clip.

If you know the field, a single encoder learns by matching wide and narrow views of the same clip, with SIGReg as a regularizer. There is no moving-average teacher, no stop-gradient step, no predictor and no decoder back to pixels. The architecture is a ViT-L/16 with 24 layers. The trade-off is video accuracy: the 7-dataset video mean is 68.94, against 72.79 for V-JEPA 1 and 74.61 for V-JEPA 2.

Sample 16 frames at 224 by 224
Normalize with ImageNet statistics
Run the encoder in block-causal mode
Read the cls token and patch tokens

Good to know:

Title: Mean score across 22 datasets
LeVJEPA 1.5 Large: 78.76%
V-JEPA 1: 79.77%
V-JEPA 2: 81.63%

• Training budget: about 5,300 unique video hours, against about 136,000 for V-JEPA 1 and about 1,700,000 for V-JEPA 2.
• Evaluation: all three encoders were tested frozen with attentive probing.
• Weights: the card says an earlier upload held weights from a different run, and that this was fixed.
• License: cc-by-nc-4.0, so it is non-commercial.
• Cost to run: no API key, account or paid service is named.
• Data it reaches: it downloads weights from Hugging Face, and the card names no other access.
• Not for: commercial use, which the license bars.

On Hugging Face, 13 November 2026

• Task: video classification
• Library: transformers
• Parameters: 303M
• Weights: about 1.2 GB in F32; about 152 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 269
• Likes: 18
• License: cc-by-nc-4.0
• Tags: transformers, safetensors, levjepa, feature-extraction, self-supervised-learning, jepa, video, image, video-classification

Links

• Model: https://huggingface.co/galilai-group/LeVJEPA-1.5-Large
• Files: https://huggingface.co/galilai-group/LeVJEPA-1.5-Large/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download galilai-group/LeVJEPA-1.5-Large

Then follow the usage in its model card. Nothing in this kit runs by itself.