Add files using upload-large-folder tool

README.md

@@ -153,7 +153,7 @@ Path(meta/embedding_base_path) / ref_path_vocab[ref_path_id]
 
 If you only use token-class graph targets (`graph_output_mode="toks"`), these external embedding shards are not required.
 
-The external token embedding shards are not included in this Hugging Face release because they are too large to upload. If you need to use `graph_output_mode="embedding"`, you can regenerate compatible embeddings with the companion repository:
+The external token embedding shards are not included in this Hugging Face release because they are too large to upload. If you need to use `graph_output_mode="embedding"`, you can regenerate compatible embeddings with:
 
 ```text
 https://github.com/yuanhuang0825/cilin-simcse.git
@@ -258,85 +258,87 @@ print("dep:", dep_kind.shape, dep_parent.shape)
 print("amr:", amr_kind.shape, amr_src.shape, amr_dst.shape, amr_edge_label.shape)
 ```
 
-### Use the RGG-VAE Dataset Loader
+### Build a PyTorch Dataset Loader
 
-The original loader is implemented as `utils.load_dataset.SkypileH5Dataset` in the companion RGG-VAE codebase.
+The following minimal example shows how to wrap one HDF5 shard as a PyTorch dataset without relying on project-specific code.
 
 ```python
+import h5py
+import torch
 from torch.utils.data import DataLoader
 
-from utils.load_dataset import SkypileH5Dataset, make_skypile_h5_collate_fn
-
-dataset = SkypileH5Dataset(
-    path="dataset/skypile1.5B_h5",
-    h5_pattern="skypile_*.h5",
-    vocab_dir="dataset/skypile1.5B_h5/vocabs",
-    return_meta=True,
-    graph_output_mode="toks",
-    graph_output_tok_top_n=30000,
-    tokenizer_input_mode="stored",
-    filter_by_max_node=True,
-    max_node=100,
-)
-
-collate_fn = make_skypile_h5_collate_fn(
-    pad_token_id=0,
-    null_id=0,
-    no_edge_id=0,
-    max_node=100,
-)
-
-loader = DataLoader(
-    dataset,
-    batch_size=32,
-    shuffle=True,
-    num_workers=4,
-    collate_fn=collate_fn,
-)
 
+class SkyGraphH5Shard(torch.utils.data.Dataset):
+    def __init__(self, h5_path):
+        self.h5_path = h5_path
+        self.h5f = None
+
+    def _file(self):
+        if self.h5f is None:
+            self.h5f = h5py.File(self.h5_path, "r")
+        return self.h5f
+
+    def __len__(self):
+        h5f = self._file()
+        return int(h5f["meta"]["num_sentences"][()])
+
+    def __getitem__(self, i):
+        h5f = self._file()
+
+        token_start = h5f["token"]["token_offsets"][i]
+        token_end = h5f["token"]["token_offsets"][i + 1]
+
+        dep_start = h5f["dep"]["node_offsets"][i]
+        dep_end = h5f["dep"]["node_offsets"][i + 1]
+
+        amr_node_start = h5f["amr"]["node_offsets"][i]
+        amr_node_end = h5f["amr"]["node_offsets"][i + 1]
+        amr_edge_start = h5f["amr"]["edge_offsets"][i]
+        amr_edge_end = h5f["amr"]["edge_offsets"][i + 1]
+
+        return {
+            "input_ids": torch.tensor(
+                h5f["token"]["tokens_flat"][token_start:token_end],
+                dtype=torch.long,
+            ),
+            "dep_kind": torch.tensor(
+                h5f["dep"]["kind_tgt_flat"][dep_start:dep_end],
+                dtype=torch.long,
+            ),
+            "dep_parent": torch.tensor(
+                h5f["dep"]["parent_flat"][dep_start:dep_end],
+                dtype=torch.long,
+            ),
+            "amr_kind": torch.tensor(
+                h5f["amr"]["kind_tgt_flat"][amr_node_start:amr_node_end],
+                dtype=torch.long,
+            ),
+            "amr_src": torch.tensor(
+                h5f["amr"]["src_flat"][amr_edge_start:amr_edge_end],
+                dtype=torch.long,
+            ),
+            "amr_dst": torch.tensor(
+                h5f["amr"]["dst_flat"][amr_edge_start:amr_edge_end],
+                dtype=torch.long,
+            ),
+            "amr_edge_label": torch.tensor(
+                h5f["amr"]["edge_label_flat"][amr_edge_start:amr_edge_end],
+                dtype=torch.long,
+            ),
+        }
+
+
+dataset = SkyGraphH5Shard("skypile_00000.h5")
+loader = DataLoader(dataset, batch_size=1, shuffle=True)
 batch = next(iter(loader))
-print(batch["tokenizer_inputs"]["input_ids"].shape)
-print(batch["dep"]["kind_tgt"].shape)
-print(batch["amr"]["edge_tgt"].shape)
-```
-
-The loader returns:
-
-```python
-{
-    "tokenizer_inputs": {
-        "input_ids": "LongTensor[L]",
-        "attention_mask": "LongTensor[L]",
-    },
-    "dep": {
-        "kind_tgt": "LongTensor[N_dep]",
-        "embed_tgt": "FloatTensor[N_dep, D]",
-        "embed_mask": "BoolTensor[N_dep]",
-        "edge_tgt": "LongTensor[N_dep, N_dep]",
-    },
-    "amr": {
-        "kind_tgt": "LongTensor[N_amr]",
-        "embed_tgt": "FloatTensor[N_amr, D]",
-        "embed_mask": "BoolTensor[N_amr]",
-        "edge_tgt": "LongTensor[N_amr, N_amr]",
-    },
-    "meta": {
-        "index": "int",
-        "dataset_index": "int",
-        "source_index": "int",
-        "shard_idx": "int",
-        "local_idx": "int",
-        "ref_path_id": "int",
-        "ref_index": "int",
-    },
-}
+print(batch["input_ids"].shape)
 ```
 
-After `make_skypile_h5_collate_fn()`, graph and token tensors are padded to batch shapes such as `[B, L_max]`, `[B, N_dep_max]`, `[B, N_dep_max, N_dep_max]`, `[B, N_amr_max]`, and `[B, N_amr_max, N_amr_max]`.
+After collation, graph and token tensors are typically padded to batch shapes such as `[B, L_max]`, `[B, N_dep_max]`, `[B, N_dep_max, N_dep_max]`, `[B, N_amr_max]`, and `[B, N_amr_max, N_amr_max]`.
 
 ## Graph Target Modes
 
-The RGG-VAE loader supports two graph target modes.
+The dataset schema supports two common graph target modes.
 
 ### `graph_output_mode="toks"`
 
@@ -353,7 +355,7 @@ The RGG-VAE loader supports two graph target modes.
 - Requires local access to the path stored in `meta/embedding_base_path`.
 - The external embedding shards are not uploaded with this dataset because of their size.
 - Compatible embeddings can be regenerated with `https://github.com/yuanhuang0825/cilin-simcse.git`.
-- Supports optional embedding transforms such as mean centering, PCA component removal, and L2 normalization in the companion training code.
+- Supports optional embedding transforms such as mean centering, PCA component removal, and L2 normalization.
 
 ## Known Limitations