Video generation model

Self-host ModelScope text-to-video on just 7GB of VRAM

1.7B parameters, 16 frames of 256x256 by default, and even an 8-second clip fits in 7GB once CPU offload is on. It is the lowest-barrier self-hosting route in video generation, and the one most likely to be derailed by a 2023 tutorial.

ModelScope · self-hosted

In video circles, ModelScope means two things at once. One is ModelScopeT2V, the text-to-video model out of Alibaba's DAMO Academy: repo ID iic/text-to-video-synthesis on the ModelScope hub, damo-vilab/text-to-video-ms-1.7b on HuggingFace, 1.7 billion parameters of which 0.5 billion are dedicated purely to temporal modelling. The other is the ModelScope hub that hosts it. Nine out of ten people searching for how to deploy it locally want the same answer: how much VRAM does this thing actually take, and will my card run it.

The answer is friendlier than expected. ModelScopeT2V follows the Stable Diffusion 1.5 lineage - a VQGAN, a text encoder, and a denoising UNet3D with spatio-temporal blocks bolted in - and outputs 16 frames at 8fps, 256x256, two seconds by default. In fp16 with enable_model_cpu_offload() and enable_vae_slicing(), 64 frames (8 seconds) peaks at 7GB. The official model card goes further: add attention slicing and PyTorch 2.0 and you can generate up to 25 seconds in under 16GB of VRAM. For a video model in 2026, that bar is absurdly low.

The price of that is age. Training drew on WebVid-10M and similar public sets, and the single most common community complaint is a Shutterstock watermark bleeding into outputs - which is exactly why cerspense/zeroscope_v2_576w and zeroscope_v2_XL were retrained. The model card states plainly that only English input is supported, the licence is CC-BY-NC-ND, and the VGen repo is marked RESEARCH/NON-COMMERCIAL USE ONLY. For video at today's quality bar the torch has passed to DiffSynth-Studio, maintained by the same ModelScope community team, which wires in Wan, HunyuanVideo, CogVideoX-5B and LTX-2 and uses layer-by-layer offload to squeeze HunyuanVideo's 129x512x384 down to 6GB. On NexGPU all of these share one image and one per-second bill.

01 —

What in the ModelScope video line still runs locally today

From the 1.7B veteran of 2023 to ModelScope's own DiffSynth-Studio engine, spanning 6GB to 24GB of VRAM.

Version	Parameters	VRAM	Context	Notes
ModelScopeT2V (iic/text-to-video-synthesis - damo-vilab/text-to-video-ms-1.7b)	1.7B (0.5B of it temporal)	fp16 ~7GB (64 frames + CPU offload + VAE slicing) / under 16GB for 25 seconds	16 frames @ 8fps, 256x256 by default	The ancestor of the whole line. VQGAN + text encoder + spatio-temporal UNet3D, exposed as TextToVideoSDPipeline in diffusers. English prompts only, CC-BY-NC-ND, watermark-prone output - best treated as the cheapest possible sanity-check model.
cerspense/zeroscope_v2_576w	1.7B (ModelScopeT2V finetune)	fp16 ~7.9GB (576x320, 30 frames)	576x320, 24-36 frames	The community retrain that drops the watermark, licensed CC-BY-NC-4.0. It is stage one of the two-stage workflow, producing fast low-resolution drafts.
cerspense/zeroscope_v2_XL	1.7B (ModelScopeT2V finetune)	fp16 ~15.3GB (1024x576, 30 frames)	1024x576, up to 30 frames	Stage two. VideoToVideoSDPipeline runs vid2vid over the 576w draft at strength=0.6 and upscales it - the best quality this older architecture will give you.
I2VGen-XL (ali-vilab, from the VGen repo)	~1B	fp16 weights ~2GB; peak VRAM for 720p is not published officially, budget a 24GB card	1280x720 image-to-video	A cascaded-diffusion image-to-video model, I2VGenXLPipeline in diffusers, and the rare weight release here under MIT rather than an NC licence. The authors admit it does poorly on anime art and pure black backgrounds.
DiffSynth-Studio (the ModelScope community's own diffusion engine, Apache-2.0)	Wires in Wan, HunyuanVideo, CogVideoX-5B, LTX-2 and more	HunyuanVideo at 129x720x1280 needs 24GB; 129x512x384 drops to 6GB	Layer-by-layer offload, FP8 quantisation, sequence parallelism, LoRA and full training	What you should actually reach for in the ModelScope ecosystem today. git clone then pip install -e . and you are running; VRAM management is its headline feature.

02 —

Pick the card by scenario - do not rent an H100 for a 1.7B model

ModelScopeT2V's VRAM appetite is small enough for the cheapest card in the fleet. Its successors are what actually eat silicon.

Run ModelScopeT2V 1.7B at 256x256, 16-64 frames, iterating on prompts
Tesla V100 32GB$0.188/GPU-hr
The peak is 7GB. V100's fp16 tensor cores are a natural fit for an SD 1.5-era UNet3D, and it is the lowest-priced card in the entire pool.
The zeroscope two-stage workflow: 576x320 draft, then vid2vid upscale to 1024x576
RTX 3090 24GB$0.193/GPU-hr
The XL stage wants 15.3GB for 30 frames. 24GB leaves headroom for VAE decode and lets you keep both 576w and XL resident instead of reloading between stages.
I2VGen-XL at 720p, or finetuning DreamVideo / VideoComposer from the VGen repo
RTX 4090 24GB$0.540/GPU-hr
Long-sequence spatio-temporal attention at 720p is a pure compute bottleneck; Ada's fp16/bf16 throughput is a large step over Ampere and roughly halves the wait per clip.
Driving Wan or HunyuanVideo at 129 frames of 720p through DiffSynth-Studio, or LoRA training
A100 PCIE 80GB$0.824/GPU-hr
That official 24GB path is bought with layer-by-layer offload, which costs speed. 80GB keeps the model resident, allows batching and training, and costs only a little more than a 4090.

03 —

Four steps to running it on NexGPU

From boot to your first exported mp4, with no quota request anywhere in the loop.

01
Boot an instance with PyTorch
Pick a Tesla V100 32GB or RTX 3090 24GB at console.nexgpu.net, boot a prebuilt PyTorch image, and get in over SSH or Jupyter to confirm the card is visible. ComfyUI and vLLM images are in the same 2,000+ catalogue if you plan to bolt a workflow on later.
```
nvidia-smi && python -c "import torch; print(torch.__version__, torch.cuda.get_device_name(0))"
```
02
Install dependencies and pull weights from the ModelScope hub
The modelscope library is at 1.39.1, Apache-2.0, and now requires Python 3.10 or newer. Watch the namespace: the repo moved from damo/ to iic/ long ago, and the mountain of 2023 tutorials still writing damo/text-to-video-synthesis will simply fail to resolve. imageio-ffmpeg is what actually writes the mp4.
```
pip install "modelscope>=1.39.1" diffusers transformers accelerate imageio imageio-ffmpeg && python -c "from modelscope import snapshot_download; print(snapshot_download('iic/text-to-video-synthesis'))"
```

Generate your first clip with diffusers

The fp16 variant plus enable_model_cpu_offload() and enable_vae_slicing() holds 64 frames inside 7GB. To go faster, swap the scheduler for DPMSolverMultistepScheduler and drop num_inference_steps to 25. The prompt has to be English.

python -c "import torch;from diffusers import DiffusionPipeline;from diffusers.utils import export_to_video;p=DiffusionPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b',torch_dtype=torch.float16,variant='fp16');p.enable_model_cpu_offload();p.enable_vae_slicing();print(export_to_video(p('a panda surfing a wave, cinematic lighting',num_frames=64).frames[0]))"

04
Chase quality with zeroscope, or jump to DiffSynth-Studio for modern models
Draft at 576x320 with zeroscope_v2_576w, then hand the frames to zeroscope_v2_XL at strength=0.6 to upscale to 1024x576 and shed the watermark on the way. If you want video at today's quality bar, install the ModelScope community's own DiffSynth-Studio - Wan, HunyuanVideo and LTX-2 all live there, with layer offload and FP8 when VRAM gets tight.
```
git clone https://github.com/modelscope/DiffSynth-Studio.git && cd DiffSynth-Studio && pip install -e .
```

What one complete production run actually costs

Priced at NexGPU list rates: spend 3 hours on a Tesla V100 32GB ($0.188/GPU-hr) dialling in prompts and settings, 3 x $0.188 = $0.564. Move to an RTX 3090 24GB ($0.193/GPU-hr) for 8 hours of batched zeroscope two-stage rendering, 8 x $0.193 = $1.544. Weights plus dependencies sit on a 15GB volume at the $0.414/GB-month median, kept 3 days before you destroy it: 15 x $0.414 x 3/30 = $0.621. Pull 20GB of finished clips down at the $0.0081/GB median egress: 20 x $0.0081 = $0.162. Total: $0.564 + $1.544 + $0.621 + $0.162 = $2.891. Billing is metered per second and priced per hour, with no minimum and no setup fee. One caveat worth internalising: compute billing stops the moment the instance stops, but storage keeps accruing until the volume is destroyed - which is why storage is a fifth of the bill above.

04 —

FAQ

Why do ModelScope text-to-video outputs have a Shutterstock watermark?

Because ModelScopeT2V trained on watermarked public video sets including WebVid-10M, and the model learned the watermark along with everything else. It is the most common complaint about this checkpoint. To avoid it, use cerspense/zeroscope_v2_576w and zeroscope_v2_XL, which were retrained specifically to remove it, or skip straight to the newer models inside DiffSynth-Studio. Either path is a few commands: spin up an RTX 3090 24GB on NexGPU at $0.193/GPU-hr, install both sets of weights, and settle the question against your own footage in an afternoon.

How much VRAM does text-to-video-ms-1.7b really need?

Three tiers. Default 16 frames in fp16 with a plain .to('cuda') runs on an 8GB-class card. Add enable_model_cpu_offload() and enable_vae_slicing() and 64 frames (8 seconds) peaks at 7GB. The official card states that with attention slicing and PyTorch 2.0 on top, up to 25 seconds fits in under 16GB. That means the cheapest card on NexGPU, the Tesla V100 32GB at $0.188/GPU-hr, has room to spare - there is no reason to queue for an A100.

Does ModelScope text-to-video accept Chinese prompts?

No. The model card is explicit: only English input is supported. A Chinese prompt will not error out, but semantics degrade visibly and the clip stops matching the description. If you need Chinese understanding you need a newer video model from the hub, loaded through DiffSynth-Studio. NexGPU's 2,000+ prebuilt images ship the PyTorch base ready, so swapping models never means rebuilding the environment.

Can I use ModelScopeT2V or zeroscope commercially?

Tread carefully. damo-vilab/text-to-video-ms-1.7b on HuggingFace is CC-BY-NC-ND, and the VGen repo is marked RESEARCH/NON-COMMERCIAL USE ONLY. The zeroscope family is CC-BY-NC-4.0, also non-commercial. I2VGen-XL is the one release in this line whose weights carry MIT. Check the current LICENSE file in the specific repo before you ship anything. We supply the card and the environment; what you run on NexGPU and under which terms is your call.

Is pulling weights from ModelScope faster than HuggingFace?

From mainland China, considerably - that is a large part of why the modelscope library exists, and snapshot_download('iic/text-to-video-synthesis') fetches everything in one line. Note that modelscope 1.39.1 requires Python 3.10 or newer, so older images will refuse to install it. NexGPU has 1,175 verified rentable nodes across 51 countries and regions, so you can pick a node close to whichever hub you rely on and reach both directly without proxy gymnastics.

Has the ModelScope video line been superseded?

As a production tool, yes - the 1.7B generation is a 2023 architecture and the quality shows it. As the cheapest way to prove out a full text-to-video pipeline, it still earns its keep at 7GB. The real successor is DiffSynth-Studio from the same ModelScope community team, carrying Wan, HunyuanVideo, CogVideoX-5B and LTX-2. NexGPU offers 75 GPU models, up to 14 GPUs per node and a maximum node VRAM of 2,152GB, so you can start on a $0.188 V100 and finish on an H200 141GB without leaving the console.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.