README.md

---
pretty_name: SkyGraph-1.5B
language:
- zh
license: apache-2.0
size_categories:
- 10M<n<100M
task_categories:
- text-generation
- feature-extraction
tags:
- chinese
- amr
- dependency-parsing
- semantic-parsing
- syntax
- graph-structured-data
- hdf5
- h5
---

# SkyGraph-1.5B

SkyGraph-1.5B is a large-scale Chinese text corpus packaged in HDF5 format with graph-structured linguistic annotations. Each example corresponds to one sentence and includes tokenizer input ids, word-level token ids, dependency parsing targets, AMR-style semantic graph targets, and references to external token embedding shards.

This release is intended for research on graph-aware language modeling, syntax-semantics representation learning, graph decoding, and Chinese text modeling.

> **Release note:** the dataset files are stored as HDF5 shards. Hugging Face can host these files, but the Dataset Viewer/Data Studio may not provide a native table preview for the full corpus unless a Parquet or JSONL sample is added separately.

## Dataset Summary

| Item | Value |
| --- | --- |
| Dataset name | SkyGraph-1.5B |
| Format | HDF5 (`.h5`) |
| Language | Chinese (`zh`) |
| Number of examples | 36,721,440 sentences |
| Number of shards | 74 |
| Disk size | Approximately 57 GB |
| Graph annotations | Dependency graph and AMR graph |
| Vocabulary files | `vocabs/*.json` |
| Conversion statistics | `conversion_stats.json` |

The HDF5 shards are named:

```text
skypile_00000.h5
...
skypile_00073.h5
```

## Repository Structure

```text
.
├── README.md
├── conversion_stats.json
├── skypile_00000.h5
├── ...
├── skypile_00073.h5
└── vocabs/
    ├── all_vocabs.json
    ├── tok_vocab.json
    ├── ref_path_vocab.json
    ├── dep_kind_vocab.json
    ├── dep_edge_vocab.json
    ├── dep_special_node_vocab.json
    ├── amr_kind_vocab.json
    ├── amr_edge_vocab.json
    ├── amr_special_node_vocab.json
    ├── amr_special_node_label_class.json
    └── dropped_unknown_noisy_label_counts.json
```

## Dataset Creation

The conversion pipeline processed 48,470,913 candidate sentences and wrote 36,721,440 valid examples. Invalid or noisy samples were skipped during conversion.

Key conversion statistics:

| Field | Count |
| --- | ---: |
| `files_total` | 10 |
| `documents_total` | 94,670 |
| `sentences_total` | 48,470,913 |
| `sentences_written` | 36,721,440 |
| `h5_shards_written` | 74 |
| `skipped_invalid_amr` | 7,838,272 |
| `skipped_invalid_dep` | 79,479 |
| `skipped_unknown_noisy_samples` | 3,823,302 |
| `skipped_missing_ref` | 8,420 |

AMR special node class counts:

| Class | Count |
| --- | ---: |
| `amr_ontology` | 114,093,292 |
| `propbank_frame` | 3,348,853 |
| `punctuation` | 857,927 |
| `date_like` | 8 |
| `unknown_noisy` | 0 |

For the full conversion report, see `conversion_stats.json`.

## Data Schema

Every `skypile_*.h5` shard uses the same schema. Variable-length fields are stored as a flat array plus offsets. For example, the `i`-th sequence in a pair of `*_flat` and `*_offsets` datasets is:

```python
flat[offsets[i]:offsets[i + 1]]
```

### `meta`

| Field | Type | Description |
| --- | --- | --- |
| `num_sentences` | scalar int64 | Number of examples in the shard. |
| `tokenizer_path` | scalar bytes | Tokenizer path used to generate `token/tokens_flat`. |
| `embedding_base_path` | scalar bytes | Base path for the external token embedding shards used by `graph_output_mode="embedding"`. |

### `token`

Pre-tokenized model input ids.

| Field | Type | Description |
| --- | --- | --- |
| `tokens_flat` | uint16 | Concatenated tokenizer token ids for all examples. |
| `token_offsets` | int64 | Per-example offsets into `tokens_flat`. |

### `tok`

Word-level token ids used to align dependency nodes, AMR nodes, and token embeddings.

| Field | Type | Description |
| --- | --- | --- |
| `tok_ids_flat` | uint32 | Concatenated word-level token ids. The ids map to `vocabs/tok_vocab.json`. |
| `tok_offsets` | int64 | Per-example offsets into `tok_ids_flat`. |

### `embedding_ref`

References to external packed token embedding shards.

| Field | Type | Description |
| --- | --- | --- |
| `ref_path_id` | uint32 | Relative embedding shard path id. The ids map to `vocabs/ref_path_vocab.json`. |
| `ref_index` | int64 | Example index inside the referenced embedding shard. |

The referenced embedding path is resolved as:

```text
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:

```text
https://github.com/yuanhuang0825/cilin-simcse.git
```

### `dep`

Dependency graphs use one node per token and encode edges through a parent array.

| Field | Type | Description |
| --- | --- | --- |
| `node_offsets` | int64 | Per-example dependency node offsets. |
| `kind_tgt_flat` | uint16 | Node kind target. `0=null`, `1=non-special`, `2=special:<punct>`. |
| `embed_tgt_flat` | int16 | In-sentence token embedding index for each node. Special nodes may be `-1`. |
| `parent_flat` | int16 | Parent node index for each node. Root or missing parent is `-1`. |
| `parent_edge_label_flat` | uint16 | Dependency edge label id from parent to child. The ids map to `vocabs/dep_edge_vocab.json`. |

When loaded by the training dataset class, the parent array is converted to a dense edge target:

```python
edge_tgt[parent, child] = parent_edge_label
```

Positions without edges use `no_edge_id`, which is `0` by default.

### `amr`

AMR graphs use an edge list and store alignment between AMR nodes and in-sentence token indices.

| Field | Type | Description |
| --- | --- | --- |
| `node_offsets` | int64 | Per-example AMR node offsets. |
| `kind_tgt_flat` | uint16 | AMR node kind target. `0=null`, `1=non-special`, `>=2` means special node. |
| `edge_offsets` | int64 | Per-example AMR edge offsets. |
| `src_flat` | int16 | AMR edge source node index. |
| `dst_flat` | int16 | AMR edge destination node index. |
| `edge_label_flat` | uint16 | AMR edge label id. The ids map to `vocabs/amr_edge_vocab.json`. |
| `amr_node_embed_offsets` | int64 | Per-example offsets for AMR nodes with token alignment. |
| `amr_node_embed_node_idx_flat` | int16 | AMR node indices with token alignment. |
| `amr_node_embed_tok_offsets` | int64 | Offsets into aligned token indices for each aligned AMR node. |
| `amr_node_embed_tok_idx_flat` | int16 | In-sentence token indices aligned to each AMR node. |

When loaded by the training dataset class, the AMR edge list is converted to a dense edge target:

```python
edge_tgt[src, dst] = edge_label
```

In `graph_output_mode="embedding"`, non-special AMR node embeddings are computed from aligned token embeddings. In `graph_output_mode="toks"`, non-special nodes are remapped to token class targets.

## Vocabulary Files

| File | Size / Entries | Description |
| --- | ---: | --- |
| `tok_vocab.json` | 5,307,229 | Word-level token to `{id, count}` mapping. |
| `ref_path_vocab.json` | 2,960 | Embedding shard relative path to id mapping. |
| `dep_kind_vocab.json` | 3 | Dependency node kinds: `null=0`, `non-special=1`, `special:<punct>=2`. |
| `dep_edge_vocab.json` | 46 | Dependency edge label to id mapping. `<no_edge>=0`. |
| `dep_special_node_vocab.json` | 1 | Dependency special node labels. Currently only `<punct>`. |
| `amr_kind_vocab.json` | 6,636 | AMR node kinds: `null=0`, `non-special=1`, `special:*>=2`. |
| `amr_edge_vocab.json` | 122 | AMR edge label to id mapping. `<no_edge>=0`. |
| `amr_special_node_vocab.json` | 6,634 | AMR special node label to special id mapping. |
| `amr_special_node_label_class.json` | 50,410 | AMR special node label classes such as `amr_ontology`, `propbank_frame`, `punctuation`, and `unknown_noisy`. |
| `dropped_unknown_noisy_label_counts.json` | 43,776 | Noisy AMR labels dropped during conversion and their counts. |
| `all_vocabs.json` | 8 groups | Combined vocabulary bundle containing graph vocabularies, `tok_vocab`, and `ref_path_vocab`. |

`tok_vocab.json` is a word-level token vocabulary, not the BPE vocabulary of an encoder tokenizer.

## Quick Start

### Read One Example With `h5py`

```python
import h5py

h5_path = "skypile_00000.h5"

with h5py.File(h5_path, "r") as h5f:
    i = 0

    token_start = h5f["token"]["token_offsets"][i]
    token_end = h5f["token"]["token_offsets"][i + 1]
    input_ids = h5f["token"]["tokens_flat"][token_start:token_end]

    dep_start = h5f["dep"]["node_offsets"][i]
    dep_end = h5f["dep"]["node_offsets"][i + 1]
    dep_kind = h5f["dep"]["kind_tgt_flat"][dep_start:dep_end]
    dep_parent = h5f["dep"]["parent_flat"][dep_start:dep_end]

    amr_node_start = h5f["amr"]["node_offsets"][i]
    amr_node_end = h5f["amr"]["node_offsets"][i + 1]
    amr_kind = h5f["amr"]["kind_tgt_flat"][amr_node_start:amr_node_end]

    amr_edge_start = h5f["amr"]["edge_offsets"][i]
    amr_edge_end = h5f["amr"]["edge_offsets"][i + 1]
    amr_src = h5f["amr"]["src_flat"][amr_edge_start:amr_edge_end]
    amr_dst = h5f["amr"]["dst_flat"][amr_edge_start:amr_edge_end]
    amr_edge_label = h5f["amr"]["edge_label_flat"][amr_edge_start:amr_edge_end]

print("input_ids:", input_ids.shape)
print("dep:", dep_kind.shape, dep_parent.shape)
print("amr:", amr_kind.shape, amr_src.shape, amr_dst.shape, amr_edge_label.shape)
```

### Build a PyTorch Dataset Loader

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


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["input_ids"].shape)
```

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 dataset schema supports two common graph target modes.

### `graph_output_mode="toks"`

- Does not read the external embedding shards.
- Remaps non-special graph nodes to token class targets.
- Uses `graph_output_tok_top_n` to keep the top-N most frequent word-level token classes.
- Maps tokens outside the top-N list to an extra unknown token kind.
- Returns placeholder `embed_tgt`; `embed_mask` is always `False`.

### `graph_output_mode="embedding"`

- Uses external token embedding shards for non-special nodes.
- Computes embedding loss only where `embed_mask=True`.
- 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.

## Known Limitations

- The files are HDF5 shards, so the Hugging Face Dataset Viewer may not provide full interactive preview or SQL support for the corpus.
- `meta/embedding_base_path` stores the original absolute path used during conversion. If you move the dataset or release embedding shards separately, update your loading code accordingly.
- External token embedding shards are not included in this release because they are too large to upload. They are not required for `graph_output_mode="toks"`, but they are required for `graph_output_mode="embedding"`. Use `https://github.com/yuanhuang0825/cilin-simcse.git` to regenerate them when needed.
- `filter_by_max_node=True` scans node offsets during dataset initialization and can be slow on first load.
- `tok_vocab.json` and `all_vocabs.json` are large. Load the smaller graph-specific vocab files when you do not need the full token vocabulary.

## Intended Uses

This dataset is suitable for:

- Chinese language modeling with syntax and semantic graph supervision.
- Dependency parsing and AMR graph representation experiments.
- Graph decoder training.
- Research on syntax-semantics alignment and graph-aware text representation learning.

## Out-of-Scope Uses

This dataset should not be used as a factual knowledge source without verification. It may contain artifacts inherited from the source corpus and from automatic graph conversion. Users should evaluate quality, bias, and legal suitability before applying it in downstream systems.

## License

SkyGraph-1.5B is released under the Apache License 2.0. See the `LICENSE` file for the full license text.

Please verify that redistribution of the source text, AMR annotations, dependency annotations, and any third-party lexical resources used by the pipeline is permitted under this release before publishing public mirrors.

## Citation and Acknowledgements

If you use SkyGraph-1.5B, please cite this dataset release and the upstream resources used to build it.

The source text is derived from [Skywork/SkyPile-150B](https://huggingface.co/datasets/Skywork/SkyPile-150B). SkyPile-150B is associated with the Skywork technical report:

```bibtex
@dataset{skygraph_1_5b,
  title        = {SkyGraph-1.5B: A Chinese Corpus with AMR and Dependency Graph Annotations},
  author       = {BoYuan Huang},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/HuangBoYuan/SkyGraph-1.5B}},
}

@misc{wei2023skywork,
  title         = {Skywork: A More Open Bilingual Foundation Model},
  author        = {Tianwen Wei and Liang Zhao and Lichang Zhang and Bo Zhu and Lijie Wang and Haihua Yang and Biye Li and Cheng Cheng and Weiwei L{\"u} and Rui Hu and Chenxia Li and Liu Yang and Xilin Luo and Xuejie Wu and Lunan Liu and Wenjun Cheng and Peng Cheng and Jianhao Zhang and Xiaoyu Zhang and Lei Lin and Xiaokun Wang and Yutuan Ma and Chuanhai Dong and Yanqi Sun and Yifu Chen and Yongyi Peng and Xiaojuan Liang and Shuicheng Yan and Han Fang and Yahui Zhou},
  year          = {2023},
  eprint        = {2310.19341},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CL},
  doi           = {10.48550/arXiv.2310.19341},
  url           = {https://arxiv.org/abs/2310.19341}
}
```

Dependency and AMR annotations were generated with [HanLP](https://github.com/hankcs/HanLP). Please also cite HanLP when using the graph annotations:

```bibtex
@inproceedings{he-choi-2021-stem,
  title     = {The Stem Cell Hypothesis: Dilemma behind Multi-Task Learning with Transformer Encoders},
  author    = {He, Han and Choi, Jinho D.},
  booktitle = {Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing},
  year      = {2021},
  pages     = {5555--5577},
  publisher = {Association for Computational Linguistics},
  doi       = {10.18653/v1/2021.emnlp-main.451},
  url       = {https://aclanthology.org/2021.emnlp-main.451}
}
```

We thank the Skywork team for releasing SkyPile-150B and the HanLP authors and maintainers for providing the dependency parsing and AMR tooling used in the annotation pipeline.

## Contact

For questions about the dataset, conversion pipeline, or graph schema, please open a discussion on the Hugging Face dataset repository or contact the maintainers listed in the repository profile.