# ZJU Eye-Pretrain 数据集使用指南

> 面向训练侧的实操手册（lsc60 本地 + HF Hub 两种用法）
>
> 数据集仓库: https://huggingface.co/datasets/MaybeRichard/zju-eye-pretrain
>
> 本地副本: `lsc60:/home/data/LSC/Data/Nature/`

---

## 1. 数据集 一眼汇总

| 资源 | 数量 | 模态 | 大小 |
|---|---:|---|---:|
| 私有 Shanghai Topcon (SS-OCT) | 419,042 images | fundus_color / slo_gray / oct_bscan | 149 GB |
| 公开 fundus (6 cohort) | 198,629 images | fundus_color + OCT (GAMMA) | 22 GB |
| 公开 OCT (19 cohort) | 488,705 images | oct_bscan | 116 GB |
| **Topcon 层 mask（NEW）** | **352,806 PNG** | oct_bscan label-map | 2.4 GB |
| **合计** | **1,106,376 + 352,806 mask** | | **~289 GB** |

**已上传:** 28 个 config, 587 文件 (586 image+meta + 1 新 mask parquet)。

---

## 2. 新增 Topcon Mask 数据 (本次更新)

### 2.1 位置

| 位置 | 路径 |
|---|---|
| HF | `manifest/private_topcon_masks.parquet` |
| lsc60 本地 | `/home/data/LSC/Data/Nature/manifest/private_topcon_masks.parquet` |
| h800 源 | `/mnt/tidal-alsh-share2/.../private_topcon/manifest/private_topcon_masks.parquet` |

### 2.2 Schema

```
private_topcon_masks.parquet  (2.4 GB, 352,806 行)
├─ image_id  : str    与 images_v1.parquet 的 image_id 一对一
└─ layer_mask: bytes  PNG 编码的 uint8 label-map (1024×992)
```

### 2.3 11 类层 label 语义（从浅到深）

| label | 区域 | label | 区域 |
|---:|---|---:|---|
| **0** | 玻璃体 (ILM 上方) | **6** | Myoid Zone |
| **1** | RNFL | **7** | Ellipsoid / Interdigitation Zone |
| **2** | GCL | **8** | RPE |
| **3** | IPL | **9** | 脉络膜 (BM 到 CSI) |
| **4** | INL | **10** | 巩膜 (CSI 下方) |
| **5** | OPL + ONL | | |

### 2.4 Join 到 image 的最小示例

```python
from datasets import load_dataset, Image
from io import BytesIO
import pandas as pd
import PIL.Image

# (1) 加载私有 Topcon images config
ROOT = "/home/data/LSC/Data/Nature"
ds_priv = load_dataset(ROOT, "private_topcon")           # 或 "MaybeRichard/zju-eye-pretrain"
ds_priv = ds_priv.cast_column("image", Image())

# (2) 加载 mask sidecar 进内存 (2.4GB 全表)
masks = pd.read_parquet(f"{ROOT}/manifest/private_topcon_masks.parquet")
masks_dict = dict(zip(masks.image_id, masks.layer_mask))

# (3) 在 DataLoader/Dataset 里按 image_id 查 mask
row = ds_priv["train"][0]
img = row["image"]                                       # PIL.Image (B-scan)
mid = row["image_id"]                                    # str
mask_bytes = masks_dict.get(mid)                         # bytes or None
if mask_bytes:
    mask = PIL.Image.open(BytesIO(mask_bytes))           # PIL.Image L 模式, 0-10 标签
```

### 2.5 内存优化（不想 2.4GB 全 load）

```python
# 用 pyarrow 流式按 image_id 取
import pyarrow.parquet as pq
import pyarrow.compute as pc

mt = pq.read_table(f"{ROOT}/manifest/private_topcon_masks.parquet")
# 后期按需 filter:
sub = mt.filter(pc.equal(mt["image_id"], "shanghai_drioct_triton_xxxx_bscan_radial_006")).to_pandas()
```

---

## 2.6 Topcon ETDRS + Demographics Sidecar (NEW)

### 位置 & 规模

| 位置 | 路径 |
|---|---|
| HF | `manifest/private_topcon_etdrs.parquet` |
| lsc60 本地 | `/home/data/LSC/Data/Nature/manifest/private_topcon_etdrs.parquet` |

- **23,454 行 × 74 列**，4 MB
- 一行 = 一个 study（按 study_hash join image manifest）
- 覆盖率：23,454 / 30,734 = 76%（原始 CSV 只导出有 ETDRS 报告的 study）

### Schema 详解

```
fda_basename, study_hash          # join key
Gender (Male/Female)
DOB (yyyy/m/d), age_at_capture    # age 范围 0-79, 注意是青少年为主
Ethnicity (Asian / African / Caucasian — 63 个非亚裔!)
eye (R/L)
TopQ_Image_Quality (float, 与 manifest 同源)

# 生物测量
Axial_Length (mm, 21-30 范围)     # 眼轴长 — 近视/眼球大小指标
Sph_Power, Cyl_Power, Corneal_Radius

# 解剖定位（人工 + 自动两套）
Manual_Disc_Center_Position_X/Y
Manual_Fovea_Position_X/Y
Auto_Disc_Center_Position_X/Y
Auto_Fovea_Position_X/Y

# 扫描参数
Fixation, Scan_Size, Scan_Resolution, Model_Name

# 5 层 × 10 ETDRS 字段 (50 列)
retina_center, retina_in_t, retina_in_s, retina_in_n, retina_in_i,
retina_out_t, retina_out_s, retina_out_n, retina_out_i, retina_average_thickness
rnfl_center, rnfl_in_t, ...
gcl_plus_center, ...                # GCL+
gcl_plus_plus_center, ...           # GCL++
choroid_center, ...
```

### 9 个 ETDRS subfield 几何

```
                     Outer (3-6mm ring)
                  +-----------------+
                  |    out_S        |
                  |  out_T ┌─in_S─┐ out_N
                  |   T ── │center│── N
                  |        └─in_I─┘
                  |    out_I        |
                  +-----------------+
                     ETDRS 标准 9-subfield 网格
                     center = 1mm, inner = 1-3mm, outer = 3-6mm
                     T/S/N/I = Temporal/Superior/Nasal/Inferior
```

5 层 contents：
- **retina**: 整个视网膜厚度（ILM 到 RPE）
- **rnfl**: 神经纤维层
- **gcl_plus** (GCL+): GCL + IPL
- **gcl_plus_plus** (GCL++): GCL + IPL + INL
- **choroid**: 脉络膜厚度（BM 到 CSI）

### Join 到 image manifest

```python
import pandas as pd

ROOT = "/home/data/LSC/Data/Nature"
imgs = pd.read_parquet(f"{ROOT}/manifest/images_v1.parquet")  # 私有 manifest
etdrs = pd.read_parquet(f"{ROOT}/manifest/private_topcon_etdrs.parquet")

# 按 study_hash join (一对多: 一个 study 12 个 OCT B-scan)
merged = imgs.merge(etdrs, on="study_hash", how="left")
# merged 行数 = 419,042, 其中 ~76% 有 ETDRS 字段, 其余 NaN
```

### 训练用法

#### A. 辅助回归目标（OCT → 厚度预测）
```python
# 用 retina_center 作为 CRT 预测目标
df = imgs.merge(etdrs[["study_hash", "retina_center"]], on="study_hash")
df = df[df.retina_center.notna() & (df.modality == "oct_bscan")]
# X = bscan image, y = retina_center (μm)
```

#### B. 条件生成（按设备 + 人口学条件生成 OCT）
```python
# 把 age, gender, axial_length, ethnicity 作为额外 condition embedding
cond = etdrs[["study_hash","age_at_capture","Gender","Axial_Length","Ethnicity"]]
```

#### C. 高度近视 / 普通 subset 拆分
```python
# 高度近视: axial_length >= 26mm (临床定义)
high_myopia = etdrs[etdrs.Axial_Length >= 26]
normal_axial = etdrs[etdrs.Axial_Length < 24]
```

#### D. caption 加 demographics 增强（手动构造）
```python
# 在 caption 文本里注入 ETDRS-derived 短语
def make_demo_caption(row):
    parts = []
    if pd.notna(row.age_at_capture):
        parts.append(f"{int(row.age_at_capture)}-year-old")
    if pd.notna(row.Gender):
        parts.append(row.Gender.lower())
    parts.append(f"{row.Ethnicity} patient")
    if pd.notna(row.Axial_Length):
        parts.append(f"axial length {row.Axial_Length:.1f}mm")
    if pd.notna(row.retina_center):
        parts.append(f"central retinal thickness {row.retina_center:.0f}μm")
    return ", ".join(parts)
```

### 重要观察

- **该 cohort 以青少年为主**：age <18 占 81%（19,051 / 23,454），mean 14.7 岁
  → 不是典型的"老年眼病数据集"，更像儿童眼科/近视筛查队列
- **眼轴长**: mean 25.5mm（轻度近视范围），21–30mm 全谱
  → 强烈推荐作为生成条件（控制眼球大小相关解剖形变）
- **Ethnicity 不全是 Asian**：63 个非亚裔（43 African + 20 Caucasian）
  → 比之前我假设的 "全 Asian" 多一点 diversity（虽然占比仍小）
- **DOB 解析失败 984 行**：原始 CSV 有 DOB 字段为空/0/0/0，age 已置 None
- **Diagnosis1-4 字段全空**：原始 CSV 没填诊断 → 没纳入 sidecar

---

## 3. 完整数据集 (parquet) 使用方式

### 3.1 28 个 config 速查

```python
from datasets import load_dataset, Image

# === 三大 batch ===
ds = load_dataset("MaybeRichard/zju-eye-pretrain", "private_topcon")    # 419k
ds = load_dataset("MaybeRichard/zju-eye-pretrain", "public_fundus")     # 199k
ds = load_dataset("MaybeRichard/zju-eye-pretrain", "public_oct")        # 489k

# === 25 单 cohort (按需取子集) ===
ds = load_dataset("MaybeRichard/zju-eye-pretrain", "kermany")           # 109k
ds = load_dataset("MaybeRichard/zju-eye-pretrain", "octa500")           # 120k
ds = load_dataset("MaybeRichard/zju-eye-pretrain", "olives")            # 63k
ds = load_dataset("MaybeRichard/zju-eye-pretrain", "uestc")             # 35k
# ... drive_vessel / messidor2_dr / idrid / refuge2_disc_cup / 
#     eyepacs_combo_dr_aug / gamma_multimodal /
#     oct_areds2 / oct_aroi / oct_neh_ut_2021 / oct_glaucoma /
#     oct_nyu_poag / oct_chiu_dme_2015 / oct_srinivasan_2014 /
#     oct_sparsity_sdoct_2012 / oct_oimhs / oct_retouch /
#     oct_thoct1800 / oct_octdl / oct_amd_sd / oct_c8 / oct_octid
```

### 3.2 必做的 cast_column

**图像在 parquet 里是 binary bytes，必须 cast 才能自动解码成 PIL.Image：**

```python
from datasets import load_dataset, Image

ds = load_dataset(ROOT, "drive_vessel")
ds = ds.cast_column("image", Image())                   # 主图像

# 带 mask 的 cohort 自动检测并 cast:
for col in ds["train"].features:
    if col.endswith("_mask") and str(ds["train"].features[col]) == "Value('binary')":
        ds = ds.cast_column(col, Image())
```

### 3.3 三批 manual concat (因 schema 差异不支持自动 "all" config)

```python
from datasets import load_dataset, concatenate_datasets, Image

ds_priv = load_dataset(ROOT, "private_topcon").cast_column("image", Image())
ds_fun  = load_dataset(ROOT, "public_fundus").cast_column("image", Image())
ds_oct  = load_dataset(ROOT, "public_oct").cast_column("image", Image())

# 取共同列, drop 各 batch 私有的 mask 列
SHARED = ["image_id", "cohort", "study_id", "patient_hash",
          "modality", "anatomy", "device_vendor", "device_model",
          "device_technology", "severity", "diagnosis_group",
          "bscan_index", "image"]

all_ds = concatenate_datasets([
    ds_priv["train"].select_columns(SHARED),
    ds_fun["train"].select_columns(SHARED),
    ds_oct["train"].select_columns(SHARED),
])
# 1.1M 行, 共同列, mask 信息需要按 batch 单独读
```

### 3.4 Streaming 模式 (大数据训练推荐, 避免 287GB 全下到本地)

```python
ds = load_dataset("MaybeRichard/zju-eye-pretrain", "public_oct", streaming=True)
ds = ds.cast_column("image", Image())

for row in ds["train"]:                                  # lazy 解码
    img = row["image"]                                   # PIL.Image
    cohort = row["cohort"]
    # train step ...
```

---

## 4. 训练侧常用过滤组合

| 目标 | 过滤 |
|---|---|
| 仅 OCT B-scan（生成式预训练 OCT） | `modality == "oct_bscan"` → ~892k |
| 仅 fundus_color | `modality == "fundus_color"` → ~178k |
| 仅 macular OCT (排除 disc 等次级解剖) | `modality == "oct_bscan" & anatomy == "macula"` |
| 仅视盘 OCT | `anatomy == "optic_disc"` |
| 仅 SS-OCT (私有 Topcon, 长波长设备特异) | `device_technology == "ss_oct"` → 374k |
| 仅 SD-OCT (排除 TD-OCT 49 张 + unknown) | `device_technology == "sd_oct"` |
| 仅 Heidelberg Spectralis 系 | `device_vendor == "heidelberg"` |
| 仅带 mask | `has_segmentation == True` → ~870k (含 Topcon 352k + 其他公开) |
| 仅有疾病 grade（弱监督） | `severity in {'mild','moderate','severe','proliferative'}` |
| 排除质量差（仅私有有质量分） | `image_quality_band not in {'poor','ungradable'}` |
| 跨模态配对 (fundus + OCT same study) | `groupby('study_id') → 同 study 内多模态 → 私有 30k 与 GAMMA 200 个 sample` |

```python
import pyarrow.parquet as pq
import pyarrow.compute as pc

# 仅 macular OCT (跨三 batch)
filters = [
    ("modality", "==", "oct_bscan"),
    ("anatomy", "==", "macula"),
]
df = pd.read_parquet(
    f"{ROOT}/manifest/oct_public_images_v1.parquet",
    filters=filters,
)
```

---

## 5. PyTorch Dataset 模板

```python
import torch, random
from torch.utils.data import Dataset, DataLoader, WeightedRandomSampler
from datasets import load_dataset, Image as HFImage
from io import BytesIO
import pandas as pd
import PIL.Image

ROOT = "/home/data/LSC/Data/Nature"

class ZjuEyeDataset(Dataset):
    """统一三批 + topcon mask 支持。"""
    def __init__(self, batches=("private_topcon","public_fundus","public_oct"),
                 modality_filter=None, caption_level="random",
                 load_topcon_masks=False, transform=None):
        # 加载三批 manifest + caption (parquet 内存) + (可选) mask sidecar
        dfs = []
        for b in batches:
            if b == "private_topcon":
                dfs.append(pd.read_parquet(f"{ROOT}/manifest/images_v1.parquet"))
            elif b == "public_fundus":
                dfs.append(pd.read_parquet(f"{ROOT}/manifest/public_images_v1.parquet"))
            elif b == "public_oct":
                dfs.append(pd.read_parquet(f"{ROOT}/manifest/oct_public_images_v1.parquet"))
        manifest = pd.concat(dfs, ignore_index=True)
        if modality_filter:
            manifest = manifest[manifest.modality.isin(modality_filter)]
        self.manifest = manifest.reset_index(drop=True)

        # captions v2 (level ∈ {short, medium, dense})
        caps = pd.concat([
            pd.read_parquet(f"{ROOT}/captions/captions_v2.parquet"),
            pd.read_parquet(f"{ROOT}/captions/public_captions_v2.parquet"),
            pd.read_parquet(f"{ROOT}/captions/oct_public_captions_v2.parquet"),
        ], ignore_index=True)
        if caption_level != "random":
            caps = caps[caps.level == caption_level]
        self.caps_dict = caps.groupby("image_id")["prompt_text"].apply(list).to_dict()
        self.caption_level = caption_level

        # Topcon mask sidecar
        self.masks_dict = {}
        if load_topcon_masks:
            mp = f"{ROOT}/manifest/private_topcon_masks.parquet"
            md = pd.read_parquet(mp)
            self.masks_dict = dict(zip(md.image_id, md.layer_mask))

        # 注意: 这个简化版需要 file_path 在磁盘 (要先 unpack parquet 出图)
        # 推荐改用 HF datasets 流式版 (见下)
        self.transform = transform

    def __len__(self): return len(self.manifest)

    def __getitem__(self, i):
        r = self.manifest.iloc[i]
        # TODO: load image from parquet (需要按 cohort 找对应 shard, 这里省略实现)
        ...
        caps = self.caps_dict.get(r.image_id, [""])
        text = random.choice(caps) if self.caption_level == "random" else caps[0]
        mask_bytes = self.masks_dict.get(r.image_id)
        mask = PIL.Image.open(BytesIO(mask_bytes)) if mask_bytes else None
        return {
            "image_id": r.image_id, "cohort": r.cohort,
            "modality": r.modality, "anatomy": r.anatomy,
            "severity": r.severity, "diagnosis_group": list(r.diagnosis_group),
            "text": text, "mask": mask,
        }
```

**推荐: 用 HF datasets 流式版直接 read parquet (无需自己 unpack):**

```python
from datasets import load_dataset, concatenate_datasets, Image as HFImage
from torch.utils.data import DataLoader

ds_oct = load_dataset(ROOT, "public_oct", streaming=True).cast_column("image", HFImage())

loader = DataLoader(
    ds_oct["train"],
    batch_size=32,
    num_workers=4,
    collate_fn=lambda b: {k: [x[k] for x in b] for k in b[0]},
)

for batch in loader:
    images = batch["image"]   # list of PIL.Image
    texts  = batch["image_id"]
    # train step ...
```

---

## 6. 切分策略 (患者级 split, 防泄漏)

> ⚠️ 不要按 image 随机切。同一患者多张 B-scan 会跨 train/val 泄漏。

```python
import numpy as np
rng = np.random.default_rng(42)
patients = manifest.patient_hash.unique()
rng.shuffle(patients)
n = len(patients)
train_p = set(patients[:int(0.9*n)])
val_p   = set(patients[int(0.9*n):int(0.95*n)])
test_p  = set(patients[int(0.95*n):])

manifest["split"] = manifest.patient_hash.map(
    lambda p: "train" if p in train_p else ("val" if p in val_p else "test"))
```

- 私有: `patient_hash = study_hash` (Topcon 已匿名,等价 file-level)
- OLIVES: `patient_hash` 跨 visit 一致 → 患者级切对了
- 多数公开 cohort: `patient_hash = study_hash` (无原始 patient ID)

---

## 7. Cohort 加权采样 (cohort 不均衡严重: Kermany 109k vs Sparsity 17)

```python
from torch.utils.data import WeightedRandomSampler

cohort_counts = manifest.cohort.value_counts()
weights = (1.0 / cohort_counts[manifest.cohort]).values
sampler = WeightedRandomSampler(weights, num_samples=len(manifest), replacement=True)

loader = DataLoader(ds, sampler=sampler, batch_size=64, num_workers=8)
```

---

## 8. 增量更新数据集 (新 cohort / 新 mask / 新 caption)

无论我后面什么时候在 HF 加新东西，lsc60 上**一行命令**同步:

```bash
ssh lsc60 'tmux new-session -d -s hfdl \
  "bash /home/data/LSC/Data/Nature/_dl.sh > /home/data/LSC/Data/Nature/dl_update.log 2>&1"'
```

`snapshot_download` 自带 etag diff，已下的瞬间跳过，只补新/改的文件。

---

## 9. 训练侧检查清单

| 项 | 必须 |
|---|---|
| `cast_column("image", Image())` | ✅ binary→PIL |
| 所有 `*_mask` 列同样 cast | ✅ |
| 患者级 split (`patient_hash`) | ✅ 防泄漏 |
| Cohort 加权采样 (大 cohort 不主导) | ⚠️ 强烈推荐 |
| `device_technology` 作为生成条件 | ⚠️ 推荐 (3 类: ss/sd/td-oct) |
| `device_model` 作训练条件 | ❌ 不推荐 (型号粒度数据稀疏) |
| caption v2: short/medium/dense 三档随机 + ~10% 空 caption (CFG) | ⚠️ 推荐 (caption_level="random") |
| Topcon layer mask 用 sidecar parquet join | ✅ (新增, 见 §2) |
| 排除质量差: `image_quality_band ∉ {poor, ungradable}` | ⚠️ 仅私有数据有质量分,公开均为 unknown |
| OCT 设备 unknown 的 NYU_POAG + C8 不进 device-conditioned 子集 | ⚠️ 避免胡编 |

---

## 10. 参考链接

- HF Dataset: https://huggingface.co/datasets/MaybeRichard/zju-eye-pretrain
- DATASET_OVERVIEW.md (详细 cohort + schema 说明): 在仓库根目录
- code/ 目录 (复现所有处理脚本): 在仓库根目录
- 私有数据 + 公开 OCT cohort 完整 cohort phrase / device / disease 映射: 见 `code/build_oct_public.py` 的 `COHORT_CONFIG` dict