scripts/encode_words.py

"""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/<modality>/<source>/part_XXXXX.parquet, columns key, words (int16 list), plus

seconds (clips, sounds). The key joins back to the text: row keys "<file>:<row>:<image>"

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 = <zip's folder>/<member> (Video-R1 paths are ./<folder>/<member>)."""
    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)