"""Pictures, clips and sounds on the pod -> the pilot's words (the same codebooks, so the band sizes and every gate measured on the pilot still hold). picture: decode -> 256 px (CPU) -> 512 px (GPU) -> SmolVLM-256M tower + connector -> 64 tokens pooled in groups of 4 -> 16 words from image_words.npz (16,384) clip: 16 frames spread evenly over the clip (2 a second when shorter than 8 s) -> the picture path per frame -> 16 tokens a frame in time order -> split into 27 time chunks, each averaged -> 27 words from video_words.npz (4,096) sound: mono 16 kHz, 10-second windows (up to 3) -> AST -> 1,212 patches pooled to 50 -> 50 words a window from audio_words.npz (8,192) word = argmax cosine to the codebook (research/tri250/build_table.assign) Output: words///part_XXXXX.parquet, columns key, words (int16 list), plus seconds (clips, sounds). The key joins back to the text: row keys "::" for parquet sources, sha1(url) for fetched pictures, the member name for archives. One part per input unit; a part on disk is skipped, so the run resumes. python3 encode_words.py image finevision python3 encode_words.py video msrvtt --limit 200 # speed check """ import os for _v in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"): os.environ.setdefault(_v, "1") # 120 workers, one thread each import sys, io, glob, time, json, hashlib, pathlib, zipfile, tarfile, argparse import multiprocessing as mp import numpy as np ROOT = pathlib.Path("/workspace/shadow"); D = ROOT / "data"; OUT = ROOT / "words"; TAB = ROOT / "tables/pilot" PARENT = "HuggingFaceTB/SmolVLM-256M-Instruct"; AST = "MIT/ast-finetuned-audioset-10-10-0.4593" PRE, SR, SEC, AWIN, VTOK, MAXF, FPS = 256, 16000, 10, 3, 27, 16, 2 def say(*a): print(time.strftime("%H:%M:%S"), *a, flush=True) # ---------------------------------------------------------------- decoders (CPU workers) def init_worker(mod): """Heavy imports happen here, before any alarm is armed (an alarm inside `import torch` broke the import on the throttled pod).""" import signal; signal.signal(signal.SIGALRM, signal.SIG_DFL) if mod == "audio": global _FE import torch; torch.set_num_threads(1) from transformers import AutoFeatureExtractor _FE = AutoFeatureExtractor.from_pretrained(AST) elif mod == "video": import av, PIL.Image else: import PIL.Image def guarded(fn): """A file that will not decode in 60 s is dropped (one bad file used to hang a whole unit).""" def g(item): import signal def boom(*_): raise TimeoutError signal.signal(signal.SIGALRM, boom); signal.alarm(60) try: return fn(item) except TimeoutError: return (item[0], None) if fn is dec_image else (item[0], None, 0.0) finally: signal.alarm(0) g.__name__ = fn.__name__ + "_guarded" return g def dec_image_g(item): return guarded(dec_image)(item) def dec_audio_g(item): return guarded(dec_audio)(item) def dec_video_g(item): return guarded(dec_video)(item) def dec_image(item): key, b = item from PIL import Image Image.MAX_IMAGE_PIXELS = 300_000_000 try: im = Image.open(io.BytesIO(b) if isinstance(b, (bytes, bytearray)) else b) im.draft("RGB", (PRE, PRE)); im = im.convert("RGB").resize((PRE, PRE), 2) return key, np.asarray(im, np.uint8) except Exception: return key, None def dec_audio(item): key, b = item import soundfile as sf from scipy.signal import resample_poly try: w, r = sf.read(io.BytesIO(b), dtype="float32") except Exception: try: # mp3 and friends import librosa w, r = librosa.load(io.BytesIO(b), sr=None, mono=True) except Exception: return key, None, 0.0 if w.ndim > 1: w = w.mean(1) if r != SR: g = np.gcd(SR, int(r)); w = resample_poly(w, SR // g, int(r) // g).astype(np.float32) sec = len(w) / SR if sec < 0.5: return key, None, sec n = min(AWIN, max(1, int(np.ceil(sec / SEC - 0.2)))) # a window only if >2 s of it is real wins = [] for k in range(n): x = w[k * SR * SEC:(k + 1) * SR * SEC] wins.append(np.pad(x, (0, SR * SEC - len(x)))) return key, _FE(wins, sampling_rate=SR, return_tensors="np")["input_values"].astype(np.float16), sec def dec_video(item): key, b = item import av try: c = av.open(io.BytesIO(b)); st = c.streams.video[0]; st.thread_type = "AUTO" rate = float(st.average_rate) if st.average_rate else 25.0 dur = float(st.duration * st.time_base) if st.duration else (float(c.duration) / 1e6 if c.duration else None) if not dur or dur <= 0: dur = (st.frames / rate) if st.frames else 8.0 nf = int(min(MAXF, max(2, round(dur * FPS)))) want = set(np.linspace(0, max(0.0, dur - 0.5 / rate), nf).round(2).tolist()) ts = sorted(want); out, j = [], 0 for fr in c.decode(video=0): t = float(fr.pts * st.time_base) if fr.pts is not None else len(out) / rate if t + 1e-6 >= ts[j]: out.append(np.asarray(fr.to_image().resize((PRE, PRE), 2), np.uint8)); j += 1 while j < len(ts) and ts[j] <= t: j += 1 if j >= len(ts): break c.close() if len(out) < 2: return key, None, dur return key, np.stack(out), dur except Exception: return key, None, 0.0 # ---------------------------------------------------------------- sources: unit -> (key, bytes) items def pq_units(pattern): return sorted(glob.glob(str(D / pattern), recursive=True)) def pq_items(f, col, keycol=None, all_images=True): import pyarrow.parquet as pq rel = os.path.relpath(f, D); pf = pq.ParquetFile(f); row = 0 cols = [col] + ([keycol] if keycol else []) for bt in pf.iter_batches(batch_size=128, columns=cols): vs = bt.column(0).to_pylist(); ks = bt.column(1).to_pylist() if keycol else [None] * len(vs) for v, k in zip(vs, ks): items = v if isinstance(v, list) else [v] for j, it in enumerate(items if all_images else items[:1]): b = it.get("bytes") if isinstance(it, dict) else it if b: yield (f"{rel}:{row}:{j}" if k is None else str(k)), b row += 1 AV_EXT = (".mp4", ".webm", ".avi", ".mkv", ".flac", ".wav", ".mp3", ".ogg"); IM_EXT = (".jpg", ".jpeg", ".png", ".webp", ".bmp", ".gif") def zip_units(pattern, per=2000, ext=AV_EXT, prefix=False): """prefix: key = / (Video-R1 paths are .//).""" out = [] for z in sorted(glob.glob(str(D / pattern), recursive=True)): with zipfile.ZipFile(z) as zz: ms = sorted(n for n in zz.namelist() if n.lower().endswith(ext)) pre = pathlib.Path(z).parent.name + "/" if prefix else "" out += [(z, ms[i:i + per], pre) for i in range(0, len(ms), per)] return out def zip_items(u): z, ms, pre = u with zipfile.ZipFile(z) as zz: for m in ms: yield pre + m, zz.read(m) def tar_items(f): with tarfile.open(f, "r|*") as t: for m in t: if m.isfile() and m.name.lower().endswith((".mp4", ".webm", ".avi", ".mkv")): yield m.name, t.extractfile(m).read() FETCH = {"pixmo-cap": D / "understanding/image/pixmo-cap", "obelics": D / "understanding/image/obelics", "pixmo-ask": D / "sft/vision/pixmo-ask"} def fetched_units(src, per=20000): import pyarrow.parquet as pq ix = pq.read_table(FETCH[src] / "fetch_index.parquet").to_pandas() ix = ix[ix.status == "ok"]; ps = ix.path.tolist() return [ps[i:i + per] for i in range(0, len(ps), per)] def fetched_items(ps): for p in ps: yield pathlib.Path(p).stem, open(p, "rb").read() # stem = sha1(url) SOURCES = { # modality, source: (units, items(unit), unit name) ("image", "finevision"): (lambda: pq_units("understanding/image/finevision/**/*.parquet"), lambda u: pq_items(u, "images")), ("image", "flux-reason-6m"): (lambda: pq_units("generation/image/flux-reason-6m/**/*.parquet"), lambda u: pq_items(u, "image", "id")), ("image", "llava-onevision"): (lambda: pq_units("sft/vision/llava-onevision/**/*.parquet"), lambda u: pq_items(u, "image")), ("image", "pixmo-cap"): (lambda: fetched_units("pixmo-cap"), fetched_items), ("image", "pixmo-ask"): (lambda: fetched_units("pixmo-ask"), fetched_items), ("image", "video-r1"): (lambda: zip_units("sft/video/video-r1/*/*.zip", 5000, IM_EXT, True), zip_items), ("image", "obelics"): (lambda: fetched_units("obelics"), fetched_items), ("audio", "audioset"): (lambda: pq_units("understanding/audio/audioset/**/*.parquet"), lambda u: pq_items(u, "audio", "video_id")), ("audio", "clotho"): (lambda: pq_units("understanding/audio/clotho/**/*.parquet"), lambda u: pq_items(u, "audio", "index")), ("audio", "audiocaps"): (lambda: pq_units("generation/audio/audiocaps/**/*.parquet"), lambda u: pq_items(u, "audio", "audiocap_id")), ("audio", "voiceassistant-400k"): (lambda: pq_units("sft/audio/voiceassistant-400k/**/*.parquet"), lambda u: pq_items(u, "question_audio")), ("audio", "wavcaps"): (lambda: zip_units("understanding/audio/wavcaps/*_full.zip") + zip_units("understanding/audio/wavcaps/Zip_files/SoundBible/*.zip"), zip_items), ("video", "msrvtt"): (lambda: zip_units("understanding/video/msrvtt/*.zip"), zip_items), ("video", "openvid-1m"): (lambda: zip_units("generation/video/openvid-1m/*.zip"), zip_items), ("video", "llava-video-178k"): (lambda: pq_units("understanding/video/llava-video-178k/**/*.tar*"), tar_items), ("video", "video-r1"): (lambda: zip_units("sft/video/video-r1/*/*.zip", prefix=True), zip_items), } # ---------------------------------------------------------------- GPU side class Enc: def __init__(self, mod): import torch self.t = torch; self.mod = mod V = np.load(TAB / f"{'video' if mod == 'video' else mod}_words.npz")["vocab"] self.C = torch.tensor(V, dtype=torch.float32, device="cuda") if mod in ("image", "video"): from transformers import AutoModelForImageTextToText, AutoProcessor m = AutoModelForImageTextToText.from_pretrained(PARENT, dtype=torch.float16).eval().cuda() ip = AutoProcessor.from_pretrained(PARENT).image_processor self.mean = torch.tensor(ip.image_mean, device="cuda").view(1, 3, 1, 1) self.std = torch.tensor(ip.image_std, device="cuda").view(1, 3, 1, 1) self.vis, self.conn = m.model.vision_model, m.model.connector else: from transformers import ASTModel self.m = ASTModel.from_pretrained(AST, dtype=torch.float16).eval().cuda() def assign(self, z): # (..., d) -> ids z = z.float(); z = z / z.norm(dim=-1, keepdim=True).clamp_min(1e-8) return (z @ self.C.T).argmax(-1).to(self.t.int16).cpu().numpy() def frames(self, x): # uint8 (n,256,256,3) -> (n,16,576) F = self.t.nn.functional x = self.t.from_numpy(x).cuda().permute(0, 3, 1, 2).float() / 255.0 x = F.interpolate(x, size=(512, 512), mode="bilinear", align_corners=False) x = ((x - self.mean) / self.std).half() z = self.conn(self.vis(pixel_values=x).last_hidden_state) return z.view(len(z), 16, 4, -1).mean(2) def images(self, arrs): with self.t.no_grad(): return self.assign(self.frames(np.stack(arrs))) def clips(self, clips): with self.t.no_grad(): z = self.frames(np.concatenate(clips)).float(); out, i = [], 0 for c in clips: zc = z[i:i + len(c)].reshape(-1, z.shape[-1]); i += len(c) cut = np.array_split(np.arange(len(zc)), VTOK) out.append(self.t.stack([zc[k].mean(0) for k in cut])) return self.assign(self.t.stack(out)) def sounds(self, wins): # filterbanks (n,1024,128) -> (n,50) with self.t.no_grad(): o = self.m(input_values=self.t.from_numpy(wins).cuda()).last_hidden_state p = o[:, 2:].float(); n = (p.shape[1] // 50) * 50 return self.assign(p[:, :n].reshape(len(p), 50, -1, p.shape[-1]).mean(2)) def run(mod, src, limit=None, workers=64): import pyarrow as pa, pyarrow.parquet as pq units_fn, items_fn = SOURCES[(mod, src)] units = units_fn(); od = OUT / mod / src; od.mkdir(parents=True, exist_ok=True) say(f"{mod}/{src}: {len(units)} units -> {od}") dec = {"image": dec_image_g, "audio": dec_audio_g, "video": dec_video_g}[mod] bs = {"image": 256, "video": 16, "audio": 48}[mod] t0, n_all, bad_all = time.time(), 0, 0 workers = workers or {"image": 10, "audio": 8, "video": 14}[mod] # the pod's cgroup gives 31 cores in all with mp.get_context("fork").Pool(workers, init_worker, (mod,)) as pool: # fork before CUDA starts enc = Enc(mod) for ui, u in enumerate(units): part = od / f"part_{ui:05d}.parquet" if part.exists() and not limit: continue keys, words, secs, buf, bad = [], [], [], [], 0 def flush(): nonlocal buf if not buf: return if mod == "image": w = enc.images([a for _, a in buf]); keys.extend(k for k, _ in buf); words.extend(list(w)) elif mod == "video": w = enc.clips([a for _, a, _ in buf]) for (k, _, s), x in zip(buf, w): keys.append(k); words.append(x); secs.append(s) else: W = enc.sounds(np.concatenate([a for _, a, _ in buf])); i = 0 for k, a, s in buf: keys.append(k); words.append(W[i:i + len(a)].reshape(-1)); secs.append(s); i += len(a) buf = [] it = items_fn(u) if limit: it = (x for _, x in zip(range(limit), it)) for r in pool.imap_unordered(dec, it, chunksize=16): if r[1] is None: bad += 1; continue buf.append(r) if len(buf) >= bs: flush() flush() cols = {"key": pa.array(keys), "words": pa.array([x.tolist() for x in words], pa.list_(pa.int16()))} if secs: cols["seconds"] = pa.array(secs, pa.float32()) pq.write_table(pa.table(cols), part if not limit else od / "speedcheck.parquet") n_all += len(keys); bad_all += bad say(f" unit {ui+1}/{len(units)}: {len(keys):,} ok, {bad} undecodable | total {n_all:,}, {n_all/(time.time()-t0):.1f}/s") if limit: break say(f"DONE {mod}/{src}: {n_all:,} encoded, {bad_all:,} undecodable, {time.time()-t0:.0f}s") if __name__ == "__main__": ap = argparse.ArgumentParser(); ap.add_argument("mod"); ap.add_argument("src") ap.add_argument("--limit", type=int); ap.add_argument("--workers", type=int, default=0) a = ap.parse_args(); run(a.mod, a.src, a.limit, a.workers)