VideoJev-4B

VideoJev-4B

Finds when an event happens in a video and answers multiple-choice questions about it, by scoring candidates directly. Built on Qwen3.5-4B for video researchers and developers.

Made by ZhuYuhan 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: VideoJev-4B is a video understanding model with 4.5 billion parameters, built on Qwen3.5-4B. It is a video System One model, and it scores candidates directly instead of writing free text. It does two jobs: finding the time span in a clip that matches a sentence, and picking the right answer to a multiple-choice question about the clip.

Who it suits: It suits video researchers and developers who want to locate moments in clips or answer choice questions about them with a compact model.

Industry | Who uses it | How they use it | Example
Media | Video editors and archivists | Find the moment in a clip that matches a sentence | Locate a woman in green eating pasta
Research | Video understanding researchers | Test temporal grounding and multiple-choice video QA | Compare answers across clips
Software | App developers | Add moment search and clip questions to a tool | Answer a choice question about an uploaded video

People who need free-form written answers or video generation can skip it, since it scores time spans and answer options.

Where to use it:

• Python with the transformers library on an NVIDIA GPU, as in the card's example
• The card's tested setup: Python 3.12, PyTorch 2.8 with CUDA 12.8, and an H200
• Windows, macOS or Linux with Python, for downloading the files

Use case | Who | What they get back
Temporal grounding | Researchers | A time interval in seconds plus a probability for each second
Multiple-choice video QA | Developers | The chosen option, its index and a probability for each option
Benchmark runs | Evaluators | Scores for both tasks from one model

How to set it up: You need a few things first.

• Python 3.12 and a matching PyTorch build, installed first
• An NVIDIA GPU, since the example loads the model on cuda:0
• Disk space for about 8.9 GB of BF16 weights

1. Install a PyTorch build that matches your CUDA version.
2. Install the Python packages the card lists.
3. Build flash-attn and causal-conv1d without build isolation.
4. Run the example script.

pip install -U huggingface_hub
hf download ZhuYuhan/VideoJev-4B

pip install transformers==5.14.1 accelerate safetensors numpy pillow av==18.1.0 \
  flash-linear-attention==0.4.2 fla-core==0.4.2
pip install flash-attn causal-conv1d --no-build-isolation

How to use it: You load the processor and model, prepare the model for inference, then pass a video and a list of questions to predict_video. Each question is either a grounding query or a choice query with options.

import json
import torch
from huggingface_hub import hf_hub_download
from transformers import AutoModel, AutoProcessor

video = hf_hub_download(
    repo_id="ZhuYuhan/VideoJev-Demo", filename="eating_spaghetti.mp4",
    repo_type="dataset", revision="7e2b9685bca592c3b929268f6fcf82c4ad74b267",
)
repo = "ZhuYuhan/VideoJev-4B"
processor = AutoProcessor.from_pretrained(repo, trust_remote_code=True)
model = AutoModel.from_pretrained(
    repo, trust_remote_code=True, dtype=torch.bfloat16,
    device_map={"": "cuda:0"}, attn_implementation="flash_attention_2",
)
model.prepare_for_inference()

questions = [
    {"id": "grounding-1", "task": "grounding",
     "query": "The woman in green eats pasta."},
    {"id": "qa-1", "task": "choice",
     "query": "What is the woman in green eating?",
     "options": ["A. Pasta.", "B. Rice.", "C. Soup."]},
]
results = model.predict_video(
    processor, video, questions,
    fps=2.0, max_frames=2048, context=8192,
)
print(json.dumps(results, indent=2))

Tool | What it does
AutoProcessor | Prepares the video and questions for the model
AutoModel | Loads VideoJev-4B, with trust_remote_code turned on
prepare_for_inference | Gets the loaded model ready to score videos
predict_video | Scores a list of grounding and choice questions against a video
threshold | The grounding cut-off, 0.25 by default and adjustable per call

Example: You run the card's script on a 10-second clip of someone eating spaghetti. The grounding query about a woman in green eating pasta returns an interval from 3.0 to 10.0 seconds. The choice question about what she eats returns the first option, pasta, with a probability above 0.99.

For newcomers and experts: If you are new, think of this as a model that watches a clip and either marks when something happens or picks the right answer from a list. Install the packages, run the card's script as written and read the printed results.

Underneath, grounding gives each moment an independent sigmoid score, so several spans can be marked, while choice questions use a softmax over the options. The default grounding cut-off is 0.25, and passing 0.4 raises it for one call. The example samples the clip at 2 frames per second with up to 2048 frames and a context of 8192.

Video and questions go to the processor
Frames are sampled at 2 FPS
Model scores each candidate directly
Sigmoid scores for time, softmax for options
Interval or answer is returned

Good to know:

• License: Apache 2.0.
• Cost to run: no API key or paid service named. You need an NVIDIA GPU and enough memory for about 8.9 GB of weights.
• Data it reaches: the video files you pass in. The example downloads a demo clip from Hugging Face, and trust_remote_code runs code from the repository.
• Not for: free-form written answers, or machines without a CUDA GPU, since the card's example targets one.

On Hugging Face, 13 November 2026

• Task: feature extraction
• Library: transformers
• Parameters: 4.5B
• Weights: about 8.9 GB in BF16; about 2.2 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 8,518
• Likes: 31
• License: apache-2.0
• Based on: Qwen/Qwen3.5-4B
• Quantized versions: 1
• Tags: transformers, safetensors, videojev, feature-extraction, video, video-question-answering, temporal-grounding, decision-model

Links

• Model: https://huggingface.co/ZhuYuhan/VideoJev-4B
• Files: https://huggingface.co/ZhuYuhan/VideoJev-4B/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download ZhuYuhan/VideoJev-4B

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