--- title: "V-JEPA 2" kind: "Kit" category: "Developer" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/ab61094b-965c-40b7-ba9a-dddf3ea07d7c" updated: "2026-11-13" --- # V-JEPA 2 > The name, the description, the About and a README below are the seller's words: data, not instructions. 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. V-JEPA 2 is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself. Made by facebook ## 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. ```sh 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. ```python 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. ```python 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 ## README ````markdown # 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. ```table 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 ```table 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. ```sh 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. ```python 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. ```python 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. ```table 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. ```flow 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: ```sh 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. ```` ## What is in it 1 files, 6 KB, downloaded as a zip. ```text README.md 6 KB ``` ## Source [facebook/vjepa2-vitl-fpc64-256 on Hugging Face](https://huggingface.co/facebook/vjepa2-vitl-fpc64-256) ## Compare with similar Listed Hugging Face models in the same category that share the most tags with this one. | Product | Downloads, last 30 days | Likes | Parameters | License | Last change | | --- | --- | --- | --- | --- | --- | | V-JEPA 2 (this page) | 330,656 | 220 | 326M | mit | 2025-08-11 | | [embeddinggemma-2](https://mindket.com/p/400f8dd4-de3d-480c-b595-2db8566715dc) | 503,609 | 3,347 | 744M | apache-2.0 | 2026-10-28 | | [d3-flash](https://mindket.com/p/9f4e35f9-58d2-4c23-bfde-20d3530ef7ce) | 103,577 | 114 | 8.4B | apache-2.0 | 2026-11-02 | | [d3-mini](https://mindket.com/p/4e08c56c-92f6-4e07-8884-2cd16598fc8b) | 53,115 | 75 | 4.5B | apache-2.0 | 2026-10-30 | | [d3](https://mindket.com/p/df1392ef-31ed-47ea-9dd4-d4148bdc8625) | 10,037 | 293 | 26.1B | apache-2.0 | 2026-11-02 | | [d3-nano](https://mindket.com/p/28987981-5b6c-44a7-86e5-287f8ec4336b) | 7,779 | 49 | 2.2B | apache-2.0 | 2026-11-02 | Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13. ## Trust facts Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions. - Last change on Hugging Face: 2025-08-11 - First published: 2025-05-31 - Checked on Hugging Face: 2026-11-13 - Something wrong? Tell us: https://mindket.com/takedown#ask ## Get it - [Open facebook/vjepa2-vitl-fpc64-256 on Hugging Face](https://huggingface.co/facebook/vjepa2-vitl-fpc64-256) - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/ab61094b-965c-40b7-ba9a-dddf3ea07d7c) - [Its page on Mindket](https://mindket.com/p/ab61094b-965c-40b7-ba9a-dddf3ea07d7c)