Update README.md

README.md

@@ -1,9 +1,329 @@
-This repo contains WebDataset shards split by top-level subfolders (e.g., `images`, `preprocessed_eeg`).
-Each shard preserves the internal hierarchy in WebDataset `__key__`.
+# README — Loading `things_eeg_2` from `nonarjb/alignvis`
+
+This repo hosts WebDataset shard sets under `things_eeg_2/`:
+
+* `things_eeg_2-images-*.tar` — images
+* `things_eeg_2-image_embeddings-*.tar` — vector embeddings (`.npy/.npz`)
+* `things_eeg_2-preprocessed_eeg-*.tar` — EEG arrays (`.npy/.npz`)
+
+Inside each shard, the WebDataset `__key__` is the file’s **relative path under the top folder (without extension)**.
+To reconstruct the original relative path, use:
+
+```
+rel_path = "<top>/" + __key__ + "." + <ext>
+```
+
+(e.g., `images/training_images/01133_raincoat/raincoat_01s.jpg`)
+
+> To use the **other dataset** (`things_meg`), just replace `dataset_dir="things_eeg_2"` with `dataset_dir="things_meg"` in the examples below.
+
+---
+
+## Install
+
+```bash
+pip install webdataset huggingface_hub pillow torch tqdm
+# Optional: faster transfers for big files
+pip install -U hf_transfer && export HF_HUB_ENABLE_HF_TRANSFER=1
+```
+
+---
+
+## Helper: list shard URLs from the Hub
+
+Create `utils_hf_wds.py`:
 
-## Load example (streaming)
 ```python
+# utils_hf_wds.py
+from huggingface_hub import HfFileSystem, hf_hub_url
+
+def hf_tar_urls(repo_id: str, dataset_dir: str, top: str, revision: str = "main"):
+    """
+    Return sorted 'resolve/<revision>' URLs for shards matching:
+        <dataset_dir>/<dataset_dir>-<top>-*.tar
+    Example: things_eeg_2/things_eeg_2-images-000000.tar
+    """
+    fs = HfFileSystem()
+    pattern = f"datasets/{repo_id}/{dataset_dir}/{dataset_dir}-{top}-*.tar"
+    hf_paths = sorted(fs.glob(pattern))  # hf://datasets/<repo_id>/...
+    rel_paths = [p.split(f"datasets/{repo_id}/", 1)[1] for p in hf_paths]
+    return [
+        hf_hub_url(repo_id, filename=p, repo_type="dataset", revision=revision)
+        for p in rel_paths
+    ]
+```
+
+---
+
+## A) Images (PIL) with original relative paths
+
+```python
+import io
+from PIL import Image
+import torch, webdataset as wds
+from utils_hf_wds import hf_tar_urls
+
+REPO = "nonarjb/alignvis"
+
+def make_images_loader(dataset_dir="things_eeg_2", batch_size=16, num_workers=4):
+    urls = hf_tar_urls(REPO, dataset_dir, top="images")
+    if not urls: raise RuntimeError("No image shards found")
+
+    def pick_image(s):
+        for ext in ("jpg","jpeg","png"):
+            if ext in s:
+                s["img_bytes"] = s[ext]
+                s["rel_path"] = f"images/{s['__key__']}.{ext}"
+                return s
+        return None
+
+    ds = (wds.WebDataset(urls, shardshuffle=False, handler=wds.handlers.warn_and_continue)
+            .map(pick_image).select(lambda s: s is not None)
+            .map(lambda s: (s["rel_path"], Image.open(io.BytesIO(s["img_bytes"])).convert("RGB"))))
+
+    return torch.utils.data.DataLoader(
+        ds, batch_size=batch_size, num_workers=num_workers, collate_fn=lambda b: b
+    )
+
+loader = make_images_loader()
+rel_path, pil_img = next(iter(loader))[0]
+print(rel_path, pil_img.size)  # e.g. images/training_images/.../raincoat_01s.jpg (W, H)
+```
+
+---
+
+## B) Image embeddings (`.npy/.npz`) → `torch.Tensor`
+
+```python
+import io, numpy as np
+import torch, webdataset as wds
+from utils_hf_wds import hf_tar_urls
+
+REPO = "nonarjb/alignvis"
+
+# Heuristics for dict-like payloads
+CANDIDATE_KEYS = ("embedding", "emb", "vector", "feat", "features", "clip", "image", "text")
+
+def _first_numeric_from_npz(npz, prefer_key=None):
+    if prefer_key and prefer_key in npz:
+        return np.asarray(npz[prefer_key])
+    # try direct numeric arrays
+    for k in npz.files:
+        a = npz[k]
+        if isinstance(a, np.ndarray) and np.issubdtype(a.dtype, np.number):
+            return a
+    # try dict-like entries with known keys
+    for k in npz.files:
+        a = npz[k]
+        if isinstance(a, dict):
+            for ck in CANDIDATE_KEYS:
+                if ck in a:
+                    return np.asarray(a[ck])
+    return None
+
+def _load_numeric_vector(payload: bytes, ext: str, prefer_key: str | None = None):
+    """Return 1D float32 vector or None if not numeric."""
+    bio = io.BytesIO(payload)
+    try:
+        arr = np.load(bio, allow_pickle=False)
+    except ValueError as e:
+        if "Object arrays" in str(e):
+            bio.seek(0)
+            obj = np.load(bio, allow_pickle=True)
+            if isinstance(obj, dict):
+                for ck in CANDIDATE_KEYS:
+                    if ck in obj:
+                        arr = obj[ck]; break
+                else:
+                    return None
+            elif isinstance(obj, (list, tuple)):
+                arr = np.asarray(obj)
+            else:
+                return None
+        else:
+            raise
+    arr = np.asarray(arr)
+    if not np.issubdtype(arr.dtype, np.number):
+        try:
+            arr = arr.astype(np.float32)
+        except Exception:
+            return None
+    return arr.reshape(-1).astype(np.float32)
+
+def make_embeddings_loader(
+    dataset_dir="things_eeg_2",
+    batch_size=64,
+    num_workers=4,
+    prefer_key: str | None = None,   # e.g., "embedding" if you know the field name
+):
+    urls = hf_tar_urls(REPO, dataset_dir, top="image_embeddings")
+    if not urls:
+        raise RuntimeError("No embedding shards found")
+
+    def pick_payload(s):
+        for ext in ("npy", "npz"):
+            if ext in s:
+                s["__ext__"] = ext
+                s["payload"] = s[ext]
+                s["rel_path"] = f"image_embeddings/{s['__key__']}.{ext}"
+                return s
+        return None
+
+    def decode_vec(s):
+        vec = _load_numeric_vector(s["payload"], s["__ext__"], prefer_key=prefer_key)
+        if vec is None:
+            # skip non-numeric payloads
+            return None
+        return (s["rel_path"], torch.from_numpy(vec))
+
+    ds = (
+        wds.WebDataset(urls, shardshuffle=False, handler=wds.handlers.warn_and_continue)
+        .map(pick_payload).select(lambda s: s is not None)
+        .map(decode_vec).select(lambda x: x is not None)
+    )
+
+    # Collate into a batch tensor; all vectors must have same dim
+    def collate(batch):
+        paths, vecs = zip(*batch)
+        D = vecs[0].numel()
+        vecs = [v.view(-1) for v in vecs if v.numel() == D]
+        paths = [p for (p, v) in batch if v.numel() == D]
+        return list(paths), torch.stack(vecs, dim=0)
+
+    return torch.utils.data.DataLoader(ds, batch_size=batch_size, num_workers=num_workers, collate_fn=collate)
+
+# ---- try it (set num_workers=0 first if you want easier debugging) ----
+if __name__ == "__main__":
+    paths, X = next(iter(make_embeddings_loader(num_workers=0, prefer_key=None)))
+    print(len(paths), X.shape)
+
+```
+
+---
+
+## C) EEG (`.npy/.npz`) — ragged-friendly (returns list of arrays)
+
+```python
+import io, re
 import webdataset as wds
-base = "https://huggingface.co/datasets/nonarjb/things_eeg_2/resolve/main"
-urls = f"{base}/things_eeg_2-images-{{000000..000099}}.tar"
-ds = wds.WebDataset(urls).to_tuple("__key__", "jpg")
+from huggingface_hub import HfFileSystem, hf_hub_url
+import numpy as np
+
+REPO_ID = "nonarjb/alignvis"   # your dataset repo on HF
+REVISION = "main"
+DATASET_DIR = "things_eeg_2"   # the folder inside the repo
+
+def _hf_eeg_urls(repo_id=REPO_ID, dataset_dir=DATASET_DIR, revision=REVISION):
+    """Collect EEG shard URLs for both possible top folders."""
+    fs = HfFileSystem()
+    urls = []
+    for top in ("Preprocessed_data_250Hz", "preprocessed_eeg"):
+        pattern = f"datasets/{repo_id}/{dataset_dir}/{dataset_dir}-{top}-*.tar"
+        hf_paths = sorted(fs.glob(pattern))
+        rel = [p.split(f"datasets/{repo_id}/", 1)[1] for p in hf_paths]
+        urls += [hf_hub_url(repo_id, filename=p, repo_type="dataset", revision=revision) for p in rel]
+    return urls
+
+def _load_subject_eeg_from_hf(subject_id: int, split: str):
+    """
+    Returns (subject_eeg_data, ch_names) for a given subject+split
+    by streaming the per-subject .npy/.npz from HF shards.
+    """
+    urls = _hf_eeg_urls()
+    if not urls:
+        raise RuntimeError("No EEG shards found in HF repo")
+    filebase = "preprocessed_eeg_training" if split == "train" else "preprocessed_eeg_test"
+    key_prefix = f"sub-{subject_id:02d}/"
+
+    ds = wds.WebDataset(urls, shardshuffle=False)
+    for s in ds:
+        # find the per-subject file
+        if ("npy" in s or "npz" in s) and s["__key__"].startswith(key_prefix) and s["__key__"].endswith(filebase):
+            ext = "npz" if "npz" in s else "npy"
+            payload = s[ext]
+            bio = io.BytesIO(payload)
+
+            # load with safe first, fallback to pickle (original code used allow_pickle=True)
+            if ext == "npz":
+                try:
+                    z = np.load(bio, allow_pickle=False)
+                except Exception:
+                    bio.seek(0); z = np.load(bio, allow_pickle=True)
+                # prefer exact fields as in your original code
+                eeg_data = z["preprocessed_eeg_data"]
+                ch_names = z["ch_names"] if "ch_names" in z else None
+            else:  # npy
+                try:
+                    obj = np.load(bio, allow_pickle=False)
+                except ValueError:
+                    bio.seek(0); obj = np.load(bio, allow_pickle=True)
+
+                # obj could be dict-like or 0-d object holding a dict
+                if isinstance(obj, dict):
+                    eeg_data = obj["preprocessed_eeg_data"]
+                    ch_names = obj.get("ch_names")
+                elif isinstance(obj, np.ndarray) and obj.dtype == object and obj.shape == ():
+                    d = obj.item()
+                    eeg_data = d["preprocessed_eeg_data"]
+                    ch_names = d.get("ch_names")
+                else:
+                    # if it’s already a numeric array (unlikely for your case)
+                    eeg_data = obj
+                    ch_names = None
+
+            return np.asarray(eeg_data), ch_names
+
+    raise FileNotFoundError(f"Subject file not found in HF shards: {key_prefix}{filebase}.(npy|npz)")
+
+
+subject_eeg_data, ch_names = _load_subject_eeg_from_hf(subject_id=1, split="train")
+print(subject_eeg_data.shape)
+print(ch_names)
+```
+
+> If some `.npy` were saved as **object-dtype**, resave as numeric arrays; otherwise you must load with `allow_pickle=True` (only if you trust the data).
+
+---
+
+## D) Download, **untar**, and use locally (byte-identical files)
+
+```python
+# 1) Download the dataset subtree
+from huggingface_hub import snapshot_download
+local_root = snapshot_download(
+    "nonarjb/alignvis", repo_type="dataset", allow_patterns=["things_eeg_2/**"]
+)
+
+# 2) Untar to a restore directory (keys preserved under each top folder)
+import tarfile, glob, pathlib
+
+restore_root = pathlib.Path("./restore/things_eeg_2")
+
+for top in ("images", "image_embeddings", "preprocessed_eeg"):
+    (restore_root / top).mkdir(parents=True, exist_ok=True)
+    for t in glob.glob(f"{local_root}/things_eeg_2/things_eeg_2-{top}-*.tar"):
+        with tarfile.open(t) as tf:
+            tf.extractall(restore_root / top)
+
+print("Restored under:", restore_root)
+```
+
+Now the folder tree mirrors the original:
+
+```python
+# Example local usage
+from PIL import Image
+import numpy as np
+
+img = Image.open("./restore/things_eeg_2/images/training_images/01133_raincoat/raincoat_01s.jpg")
+vec = np.load("./restore/things_eeg_2/image_embeddings/some/file.npy")
+eeg = np.load("./restore/things_eeg_2/preprocessed_eeg/s01/run3/segment_0001.npy", allow_pickle=False)
+```
+
+---
+
+### Notes
+
+* WebDataset can also read **local** shards by passing `file://` URLs instead of `https://`.
+* If your shards are named differently, tweak `hf_tar_urls(..., top="...")` and the `rel_path` prefixes (`images/`, `image_embeddings/`, `preprocessed_eeg/`).
+* To batch EEG tensors, implement padding in the `collate` function.