Upload folder using huggingface_hub

app.py

@@ -16,6 +16,7 @@ encode of the structure video and first frame — runs here, on the card, inside
 
 from __future__ import annotations
 
+import gc
 import json
 import os
 import sys
@@ -25,6 +26,15 @@ import traceback
 from functools import cache
 from pathlib import Path
 
+# The render packs ~96k rows through a 50-layer 33B trunk: the feed-forward alone allocates ~5.6 GB
+# in one tensor, and the allocator's default 2 MB-block caches cannot hand back a run that large
+# once the VAE encode has left a few GiB of odd-sized blocks behind — the failure reads as
+# `NVML_SUCCESS == r INTERNAL ASSERT FAILED ... CUDACachingAllocator.cpp` with free memory still
+# showing on the card. Expandable segments let one segment grow instead of needing contiguity.
+_ALLOC = os.environ.get("PYTORCH_CUDA_ALLOC_CONF", "")
+if "expandable_segments" not in _ALLOC:
+    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = f"{_ALLOC},".lstrip(",") + "expandable_segments:True"
+
 # Before anything that could initialize CUDA: `import spaces` patches `torch.cuda` so the model
 # load can happen at startup rather than on GPU time.
 import spaces
@@ -151,6 +161,22 @@ def load_models() -> str | None:
     return LOAD_ERROR
 
 
+def release_card() -> None:
+    """Send the conditioners home and give their blocks back to the driver.
+
+    The release runs the encoder and the renderer in separate processes because they do not fit
+    together: `del encoder; free_cuda()`. Here they share a process, so the same release has to be
+    spelled out — the float32 visual VAE (9.7 GiB) plus the audio VAE (0.56 GiB) plus whatever the
+    158-frame pixel encode left in the allocator is exactly the headroom the 33B trunk needs for the
+    ~5.6 GB feed-forward activation each of the four evaluations allocates in one tensor.
+    """
+    for module in (VAE, getattr(CONDITIONERS, "audio_vae", None)):
+        if isinstance(module, torch.nn.Module):
+            module.to("cpu")
+    gc.collect()
+    torch.cuda.empty_cache()
+
+
 # ── the encode chain, over the one VAE ──────────────────────────────────────
 
 _CHAIN = {}
@@ -350,11 +376,16 @@ def _generate(structure, first, embeds, tags, height, width, seed):
     if PLACEMENT == "lazy" and CORE is not None:
         CORE.model.to("cuda")
         CORE.device = torch.device("cuda")
-        VAE.to("cuda")
 
     chain = latents_chain()
     from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3VideoReference
 
+    # The structure encode below needs the visual VAE on the card; the sample that follows does not
+    # (see the release below). Bring back whatever an earlier request sent home.
+    VAE.to(CORE.device)
+    if getattr(CONDITIONERS, "audio_vae", None) is not None:
+        CONDITIONERS.audio_vae.to(CORE.device)
+
     # The references exactly as the release's `encode()` built them: the structure video
     # center-cropped to the canvas and prepared, the first frame as a STILL_FRAMES-long still.
     video, fps = pre.read_video(structure, FRAMES / pre.FPS + 0.5)
@@ -409,19 +440,34 @@ def _generate(structure, first, embeds, tags, height, width, seed):
         {"observations": observations, "latent_frames": frame_count, "canvas": [height, width]}
     )})
 
+    # Everything the encode needed is now in the member file, so hand the card back before sampling.
+    # The release does the same thing with `del encoder; free_cuda()` — its encoder and its renderer
+    # never share the card — and here it is what makes room for the ~5.6 GB feed-forward activation
+    # the 33B trunk allocates per step. The VAE is 9.7 GiB of float32 (the release's own validation
+    # decoder runs in FP32) and the 158-frame pixel encode leaves tensors of the same order behind,
+    # so both it and the reference stack go home first; the decoder gets them back below.
+    del state, target_state, refs, structure_frames, target, tensors
+    release_card()
+
     stream = object.__new__(H3OmniStream)
     stream.root, stream.current_plan_fingerprint, stream.aligned_control = "/", "render", False
     batch = stream.read({"id": "request", "member": member})
     began = time.time()
+    # `no_grad`, as the release's own `render_member` samples.
     with torch.no_grad():
         latents = CORE.generate(batch, noise_seed=int(seed), num_inference_steps=FORWARDS + 1, renoise=True)
     sampled = time.time() - began
+    del batch
+    VAE.to(CORE.device)  # the decode needs the visual VAE, and only the decode
     decoded = decode_h3_latents(VAE, latents, device=CORE.device)
     data = _mp4_bytes(decoded)
+    shape = tuple(decoded.shape)
     os.unlink(member)
+    del decoded, latents
+    release_card()
     print(
         f"[{VERSION}] sampled {FORWARDS} steps in {sampled:.0f}s; "
-        f"{decoded.shape[-3]} frames at {decoded.shape[-2]}x{decoded.shape[-1]}",
+        f"{shape[-3]} frames at {shape[-2]}x{shape[-1]}",
         flush=True,
     )
     return data
@@ -513,6 +559,29 @@ CSS = """
 .dark .gradio-container { color: var(--body-text-color); }
 """
 
+# The release's own `examples/sem-highway_synthwave/prompt.txt`, inlined: a `gr.Textbox` example
+# cell is a *string*, not a path — Gradio would paste `examples/prompt.txt` into the box verbatim
+# rather than reading the file.
+EXAMPLE_PROMPT = """subject_definitions:
+<Video 1> is a semantic segmentation of the scene, one flat colour per class (road, sidewalk, building, vegetation, vehicle, pedestrian, sky and so on), frame by frame, from the same camera as the target video.
+<Video 2> is the first frame of [Shot 1], held still.
+
+summary:
+[keyframe completion + reference generation] The target video begins from <Video 2> and follows the frame-by-frame structure and motion of <Video 1>. A retro synthwave highway run: a neon-trimmed coupe overtakes a glowing semi-truck, flies under a neon gantry and overpass at dusk, and slides back into its lane.
+
+retention_analysis:
+<Video 1> (frame-by-frame layout of every class and camera): attribute_transfer - every region keeps its class, outline and place; materials, colours and lighting are not given by <Video 1>; the flat class colours are not shown.
+<Video 2> ([Shot 1] first frame): fully_preserved - the composition, subjects, materials, colours and lighting of <Video 2> are the target video's first frame.
+
+detailed_description:
+The target video is a stylised synthwave animation in the look of an eighties retro-futuristic music video, with a magenta-to-violet sunset gradient sky, a huge striped setting sun on the horizon, neon pink and cyan edge lighting, glossy reflective surfaces and a light film grain. [Shot 1] The shot begins from <Video 2>. The camera trails a few metres behind and above a black wedge-shaped sports coupe with a glowing cyan light strip across its tail, in the right lane of a six-lane divided highway whose lane lines glow hot pink. Ahead sits the back of a chrome semi-trailer outlined in purple neon, pulled by a tractor with a glowing grille. After half a second the coupe glides left into the middle lane, the camera tilting with it, and begins to close on the truck. The trailer's mirror-like side slides by on the right, reflecting the sunset, then its glowing wheels and the cab with chrome stacks, passing within a couple of metres. Midway, a gantry with two glowing signs in retro lettering sweeps overhead. Further up the road, tail lights of an SUV and a sedan streak away in the fast lane, with a hatchback, a box truck and a van glowing ahead. Across a dark median lined with tall lamp posts topped by pink light bars, oncoming cars and a coach race past as streaks of white light. Near the end the coupe flashes under a concrete overpass trimmed with neon tubes, while a glowing SUV and a delivery truck cross above, their light trails painting streaks along the bridge railing. Clear of the truck, the coupe slides back into the right lane toward the setting sun. The coupe stays planted through every move, rocking slightly over expansion joints, and the camera follows with a slight lag so each lane change feels smooth, heavy and rhythmic, like a slow camera move in a music video. Guard rails gleam with reflected pink light, palm-like trees and stylised pines stand as black silhouettes, utility poles and their wires cut thin lines across the gradient sky, and low warehouses with glowing windows and purple hills fade toward a wireframe-like horizon.
+
+overall_soundscape:
+Smooth tyre roar and wind with a punchy engine note as the coupe overtakes, a deep whoosh past the truck and a hollow echo under the overpass.
+
+non_diegetic_music:
+N/A"""
+
 with gr.Blocks(title="SolarRenderer") as demo:
     gr.Markdown(INTRO)
 
@@ -537,7 +606,7 @@ with gr.Blocks(title="SolarRenderer") as demo:
     gr.Examples(
         # The release's own example: the semantic-map highway structure, its first frame, and the
         # full synthwave prompt the authors ship in examples/sem-highway_synthwave/.
-        examples=[["examples/prompt.txt", "examples/structure.mp4", "examples/first.png"]],
+        examples=[[EXAMPLE_PROMPT, "examples/structure.mp4", "examples/first.png"]],
         inputs=[prompt, structure, first],
         outputs=result,
         fn=generate,