V-JEPA 2

V-JEPA 2

Turns videos and images into embeddings for video classification, retrieval, or as the video encoder of a vision-language model. Built by FAIR at Meta for developers and researchers who work with video.

Made by facebook 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: V-JEPA 2 is a video understanding model developed by FAIR at Meta. It builds on the pretraining goals of the earlier V-JEPA and scales up both the data and the model. This checkpoint reads 64 frames of a video and returns an embedding that stands for the clip.

It is meant to represent videos and images for classification, retrieval, or as the video encoder inside a vision-language model.

Who it suits: Developers and researchers who need compact representations of video suit it best. You work with it in Python through the transformers library.

Industry | Who uses it | How they use it | Example
Video search | Machine learning engineers | Retrieve clips by comparing video embeddings | Encode a library of clips and rank them by similarity
Video analysis | Research teams | Classify video content from embeddings | Train a small classifier on top of the video embeddings
Vision-language systems | Model builders | Use it as the video encoder of a vision-language model | Feed its embeddings into a larger model

Anyone who wants a finished video app can skip it, because the page holds a model and sample code.

Where to use it: You run it yourself in Python, on Windows, macOS or Linux.

• Python scripts that use the transformers library
• Windows, macOS or Linux with Python installed
• The project's code repository, which the model card names

Use case | Who | What they get back
Video classification | Machine learning engineers | Embeddings you feed to a classifier
Retrieval | Search developers | Embeddings you compare across clips
Video encoder for a VLM | Model builders | A vector summary of each video

How to set it up: You need Python, the latest transformers, and the libraries the sample code imports.

• Python on Windows, macOS or Linux
• The latest transformers, installed as the model card describes
• torch, torchcodec and numpy, which the video sample imports

1. Install Python.
2. Install the latest transformers, following the model card.
3. Download the model files with the Hugging Face hub tools.
4. Load the model and its video processor by name.

pip install -U huggingface_hub
hf download facebook/vjepa2-vitl-fpc64-256

How to use it: Load the model and processor with the checkpoint name, then pick 64 frames from your video, since this model uses that number. After that you run the processor and ask the model for its vision features.

from transformers import AutoVideoProcessor, AutoModel

hf_repo = "facebook/vjepa2-vitl-fpc64-256"

model = AutoModel.from_pretrained(hf_repo)
processor = AutoVideoProcessor.from_pretrained(hf_repo)

Create a VideoDecoder named vr from your own video file, then run these lines to get the embeddings.

import torch
from torchcodec.decoders import VideoDecoder
import numpy as np

frame_idx = np.arange(0, 64) # choosing some frames. here, you can define more complex sampling strategy
video = vr.get_frames_at(indices=frame_idx).data  # T x C x H x W
video = processor(video, return_tensors="pt").to(model.device)
with torch.no_grad():
    video_embeddings = model.get_vision_features(**video)

print(video_embeddings.shape)

For a single image, copy the image to the number of frames you want before calling the model.

Tool | What it does
AutoModel | Loads the V-JEPA 2 model from the checkpoint name
AutoVideoProcessor | Prepares video frames for the model
VideoDecoder | Reads frames out of a video file
get_vision_features | Returns the embeddings for the frames you pass in

Example: You decode 64 frames from a video of your own, run the processor, and call get_vision_features without gradients. The last line prints the shape of the video embeddings, which you then use for classification or retrieval.

For newcomers and experts: Think of the model as a tool that watches a clip and writes down what it saw as a list of numbers. Your first small try is to load the model and processor with the checkpoint name and check that both load.

Under the hood, it extends the pretraining objectives of V-JEPA and trains at larger data and model sizes. It works on a fixed number of frames per clip, 64 for this checkpoint, so you choose the sampling strategy. A still image goes in by repeating it to fill the frame count.

A video file or an image
Sample 64 frames, or repeat the image
The processor builds model inputs
The model returns vision features

Good to know: This checkpoint expects 64 frames per video, and the model card points to the project's code repository and documentation for more examples.

• Size: 326M parameters, with weights of about 1.3 GB in F32, stored as Safetensors
• Other versions: Hugging Face lists 5 quantized and 13 fine-tuned versions made by other people
• License: mit
• Cost to run: none named
• Data it reaches: the video or image files you load, and the model files downloaded from Hugging Face

On Hugging Face, 13 November 2026

• Task: video classification
• Library: transformers
• Parameters: 326M
• Weights: about 1.3 GB in F32; about 163 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 330,656
• Likes: 220
• License: mit
• Quantized versions: 5
• Fine-tunes: 13
• Tags: transformers, safetensors, vjepa2, feature-extraction, video, video-classification

Links

• Model: https://huggingface.co/facebook/vjepa2-vitl-fpc64-256
• Files: https://huggingface.co/facebook/vjepa2-vitl-fpc64-256/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download facebook/vjepa2-vitl-fpc64-256

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