SAVRN
Search Contact SAVRN

Open-weight model · Video classification

vjepa2-vitl-fpc64-256

by AI at Meta facebook/vjepa2-vitl-fpc64-256

A frontier video understanding model developed by FAIR, Meta, which extends the pretraining objectives of VJEPA, resulting in state-of-the-art video understanding capabilities, leveraging data and model sizes at scale. The code is released in this repository.

Parameters326M
Context
Weights6.4 GB
Licensemit
AccessOpen weights
Monthly Downloads183k

Runs On

What it takes to serve vjepa2-vitl-fpc64-256 (326M parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.

PrecisionWeightsMemory neededCheapest setupPer hourAlso fits
16-bit 0.7 GB 0.8 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
8-bit 0.3 GB 0.4 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
4-bit 0.2 GB 0.2 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00

Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Sep 18, 2026.

Model Card

By AI at Meta, published under mit, revision b3c1679b7c34.

A frontier video understanding model developed by FAIR, Meta, which extends the pretraining objectives of VJEPA, resulting in state-of-the-art video understanding capabilities, leveraging data and model sizes at scale. The code is released in this repository. To run V-JEPA 2 model, ensure you have installed the latest transformers: V-JEPA 2 is intended to represent any video (and image) to perform video classification, retrieval, or as a video encoder for VLMs. To load a video, sample the number of frames according to the model. For this model, we use 64. To load an image, simply copy the image to the desired number of frames. For more code examples, please refer to the V-JEPA 2…

Read AI at Meta's full model card

V-JEPA 2

A frontier video understanding model developed by FAIR, Meta, which extends the pretraining objectives of VJEPA, resulting in state-of-the-art video understanding capabilities, leveraging data and model sizes at scale. The code is released in this repository.

Installation

To run V-JEPA 2 model, ensure you have installed the latest transformers:

pip install -U git+https://github.com/huggingface/transformers

Intended Uses

V-JEPA 2 is intended to represent any video (and image) to perform video classification, retrieval, or as a video encoder for VLMs.

from transformers import AutoVideoProcessor, AutoModel

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

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

To load a video, sample the number of frames according to the model. For this model, we use 64.

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

video_url = "https://huggingface.co/datasets/nateraw/kinetics-mini/resolve/main/val/archery/-Qz25rXdMjE_000014_000024.mp4"
vr = VideoDecoder(video_url)
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)

To load an image, simply copy the image to the desired number of frames.

from transformers.image_utils import load_image

image = load_image("https://huggingface.co/datasets/merve/coco/resolve/main/val2017/000000000285.jpg")
pixel_values = processor(image, return_tensors="pt").to(model.device)["pixel_values_videos"]
pixel_values = pixel_values.repeat(1, 16, 1, 1, 1) # repeating image 16 times

with torch.no_grad():
    image_embeddings = model.get_vision_features(pixel_values)    

print(image_embeddings.shape)

For more code examples, please refer to the V-JEPA 2 documentation.

Citation

@techreport{assran2025vjepa2,
  title={V-JEPA~2: Self-Supervised Video Models Enable Understanding, Prediction and Planning},
  author={Assran, Mahmoud and Bardes, Adrien and Fan, David and Garrido, Quentin and Howes, Russell and
Komeili, Mojtaba and Muckley, Matthew and Rizvi, Ammar and Roberts, Claire and Sinha, Koustuv and Zholus, Artem and
Arnaud, Sergio and Gejji, Abha and Martin, Ada and Robert Hogan, Francois and Dugas, Daniel and
Bojanowski, Piotr and Khalidov, Vasil and Labatut, Patrick and Massa, Francisco and Szafraniec, Marc and
Krishnakumar, Kapil and Li, Yong and Ma, Xiaodong and Chandar, Sarath and Meier, Franziska and LeCun, Yann and
Rabbat, Michael and Ballas, Nicolas},
  institution={FAIR at Meta},
  year={2025}
}

Configuration

Architecture
VJEPA2Model
Layers
24
Hidden size
1,024
Attention heads
16
Stored precision
float32
Model type
vjepa2

Identity and Version

Repository
facebook/vjepa2-vitl-fpc64-256
Publisher
AI at Meta
Task
Video classification
Modality
Video
Library
transformers
Parameters
326M parameters
Languages
Not stated by the source
Revision
b3c1679b7c34d3255ef3547f27c7b226aefab26f
First published
2025-05-31
Last updated
2025-08-11

Files and Weights

8 files, 6.4 GB in total. The weights are 2 files totalling 6.4 GB in pth, safetensors.

Weights2 files · 6.4 GB
Configuration2 files · 2.1 KB
Documentation1 file · 3.2 KB
Other2 files · 549.1 KB
Repository1 file · 1.5 KB
Every file
FileTypeSizeSHA-256
model.safetensorsWeights1.3 GB 25466aef8572
original/model.pthWeights5.1 GB 5346856ec9df
config.jsonConfiguration785 B
video_preprocessor_config.jsonConfiguration1.3 KB
README.mdDocumentation3.2 KB
notebook.ipynbOther4.3 KB
notebook_finetuning.ipynbOther544.8 KB
.gitattributesRepository1.5 KB

License and Download

License
mit
Access
Open weights, no gate
Download size
6.4 GB
Download from AI at Meta

Released by AI at Meta through its official repository on Hugging Face. Read the license.

Memory Requirements

PrecisionWeights in memory
As published6.4 GB
16-bit0.7 GB
8-bit0.3 GB
4-bit0.2 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Built on This Model

Questions About vjepa2-vitl-fpc64-256

How much GPU memory does vjepa2-vitl-fpc64-256 need?

About 0.8 GB at 16-bit and 0.2 GB at 4-bit: the weights (326M parameters) plus a working margin. A long context needs more.

What is the cheapest GPU to run vjepa2-vitl-fpc64-256 on?

At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.

Can I use vjepa2-vitl-fpc64-256 commercially?

Yes. vjepa2-vitl-fpc64-256 is released under MIT License. The MIT License is a short permissive license. It permits commercial use, modification and redistribution, provided the copyright notice and permission notice are included.

Similar Models

Model · Video classification

vjepa2.1-vit-large-384

Antonio Apicella

A HuggingFace-format conversion of Meta AI's V-JEPA 2.1 ViT-L/16 video encoder and predictor, operating at 384x384 resolution. The weights are Meta's, copied without modification. This repository provides the transformers-compatible packaging plus a documented numerical validation against the original implementation. An equivalent community port already exists (Dev-Jahn/vjepa2.1-vitl-fpc64-384). This repository adds an independently reproduced conversion together with the validation results below. Forward outputs match the existing port to all reported digits. The only structural change is that the fused QKV projection of each attention block is split into separate query / key / value…

Open weights mit 328M parameters transformers

VideoMAE model pre-trained on Kinetics-400 for 1600 epochs in a self-supervised way. It was introduced in the paper VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training by Tong et al. and first released in this repository. Disclaimer: The team releasing VideoMAE did not write a model card for this model so this model card has been written by the Hugging Face team. VideoMAE is an extension of Masked Autoencoders (MAE) to video. The architecture of the model is very similar to that of a standard Vision Transformer (ViT), with a decoder on top for predicting pixel values for masked patches. Videos are presented to the model as a sequence of…

Open weights cc-by-nc-4.0 343M parameters transformers

VideoMAE model pre-trained for 1600 epochs in a self-supervised way and fine-tuned in a supervised way on Kinetics-400. It was introduced in the paper VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training by Tong et al. and first released in this repository. Disclaimer: The team releasing VideoMAE did not write a model card for this model so this model card has been written by the Hugging Face team. VideoMAE is an extension of Masked Autoencoders (MAE) to video. The architecture of the model is very similar to that of a standard Vision Transformer (ViT), with a decoder on top for predicting pixel values for masked patches. Videos are presented to…

Open weights cc-by-nc-4.0 304M parameters transformers

Model · Video classification

kandinsky-videomae-large-camera-motion

AI Forever

VideoMAE model(large) variant that has been finetuned for multi-label video classification (a video can belong to multiple classes simultaneously) for camera motion classification on internal dataset. The model predicts 18 different camera motion 'arcleft', 'arcright', 'dollyin', 'dollyout', 'panleft', 'panright', 'pedestaldown', 'pedestalup', 'rollleft', 'rollright', 'static', 'tiltdown', 'tiltup', 'truckleft', 'truckright', 'undefined', 'zoomin', 'zoomout' and and 3 shot type classes: 'pov', 'shake', 'track'. Model was trained to associate entire video with camera labels, not frame-level motions(!): [input video] -> label/labels (because multilabel) for all video. So, if this camera…

Open weights 304M parameters transformers

Model · Video classification

videomae-large-finetuned-deepfake-subset

Mai

This model is a fine-tuned version of MCG-NJU/videomae-large on the Deepfake Detection Challenge dataset. It achieves the following results on the evaluation set: The following hyperparameters were used during training: - learningrate: 5e-05 - trainbatchsize: 8 - evalbatchsize: 8 - lrschedulertype: linear - lrschedulerwarmupratio: 0.1 - trainingsteps: 4470 - mixedprecisiontraining: Native AMP - Transformers 4.44.2 - Pytorch 2.5.0+cu121 - Datasets 3.1.0 - Tokenizers 0.19.1

Open weights cc-by-nc-4.0 304M parameters transformers

Model · Video classification

VideoMAEv2-Large

OpenGVLab

VideoMAEv2-Large model pre-trained for 800 epochs in a self-supervised way on UnlabeldHybrid-1M dataset. It was introduced in the paper [[CVPR23]VideoMAE V2: Scaling Video Masked Autoencoders with Dual Masking](https://arxiv.org/abs/2203.12602) by Wang et al. and first released in GitHub. You can use the raw model for video feature extraction. Here is how to use this model to extract a video feature

Open weights cc-by-nc-4.0 304M parameters