| # 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`: | |
| ```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 | |
| 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. | |