Update README.md

README.md

@@ -6,10 +6,10 @@ tags:
   - biology
   - genomics
   - dna
-  - pretraining
-  - carbon
-  - parquet
-pretty_name: Carbon pretraining corpus
+pretty_name: Carbon Pretraining Corpus
+size_categories:
+  - 1T<n<10T
+language: []
 configs:
   - config_name: eukaryote_generator
     data_files:
@@ -29,121 +29,164 @@ configs:
         path: prokaryote_evo2/*.parquet
 ---
 
-# Carbon pretraining corpus
+# 🧬 Carbon Pretraining Corpus
 
-Private aggregation of the DNA-side sources used for Carbon pretraining, mirrored
-into one Hub dataset with four loadable configs. The goal is to make the
-pretraining mixture reproducible without re-stitching data from multiple upstream
-repositories.
+> **~127M DNA & RNA sequences · 1 trillion nucleotides** — the DNA pretraining mixture used to train [Carbon](https://github.com/hf-carbon/carbon), a genomic foundation model.
 
-All files are stored as Parquet. OpenGenome2 JSONL sources were converted to
-Parquet and their `metadata.file_path` values were scrubbed so the metadata keeps
-only useful upstream provenance such as `{"source": "data_mrna_train_chunk1.jsonl.gz"}`
-and, where present, the upstream `record` id.
+This dataset is a collection of data sources intended for training genomic foundation models, such as Carbon. It contains DNA and RNA sequences spanning eukaryote and prokaryote species, spanning fungi, plants, animals, bacteria...
+And has almost 1T DNA base pairs (160B tokens with Carbon's 6-mer tokenizer). 
 
-## Subsets
+| Subset | Domain | Source | Size | Rows | Nucleotides |
+|---|---|---|---:|---:|---:|
+| `eukaryote_generator` | Eukaryote genomes | GenerTeam / GENERATOR | 376.8 GB | 48.02 M | ~420 Gbp |
+| `mrna_evo2` | Messenger RNA | Arc Institute / OpenGenome2 | 54.8 GB | 52,702,454 | ~115.9 Gbp |
+| `mrna_splice_evo2` | mRNA + splice & promoter | Arc Institute / OpenGenome2 | 92.9 GB | 56,877,762 | ~197.4 Gbp |
+| `prokaryote_evo2` | Prokaryote genomes (GTDB + IMG/PR) | Arc Institute / OpenGenome2 | 166.0 GB | 17,408,059 | ~357.5 Gbp |
 
-| Config | Upstream source | Files | Size | Rows / sequence stats |
-|---|---:|---:|---:|---|
-| `eukaryote_generator` | [GenerTeam/pretrain_data_eukaryote](https://huggingface.co/datasets/GenerTeam/pretrain_data_eukaryote) | 456 | 376.80 GB | Rich schema with `sequence`, `taxonomy`, `species_type`, `gene_type`, coordinates, and boundary markers. A sampled fungi shard has 187,500 rows with mean sequence length ~1,631 nt. |
-| `mrna_evo2` | [OpenGenome2 mRNA](https://huggingface.co/datasets/arcinstitute/opengenome2/tree/main/json/pretraining_or_both_phases/mrna) | 11 | 54.78 GB | 52,702,454 rows; 115.94 Gbp total; mean 2,200 nt; min 64; max 99,994. |
-| `mrna_splice_evo2` | [OpenGenome2 mRNA splice/promoter](https://huggingface.co/datasets/arcinstitute/opengenome2/tree/main/json/pretraining_or_both_phases/mrna_splice_promoter) | 19 | 92.89 GB | 56,877,762 rows; 197.36 Gbp total; mean 3,470 nt; min 96; max 122,533. |
-| `prokaryote_evo2` | [OpenGenome2 GTDB v220 + IMG/PR](https://huggingface.co/datasets/arcinstitute/opengenome2/tree/main/json/pretraining_or_both_phases/gtdb_v220_imgpr) | 34 | 165.98 GB | 17,408,059 rows; 357.45 Gbp total; mean 20,533 nt; min 20; max 16,040,666. |
+> ℹ️ Nucleotides are counted in **base pairs (Gbp = billion nucleotides)**. The prokaryote subset has the longest individual sequences (mean ~20 K nt; max ~16 M nt) because it contains whole chromosomal chunks.
 
-Test splits from opengenome2 are not included (this is a pretraining corpus).
 
-## Schema
+## What is this?
 
-`eukaryote_generator` preserves the GenerTeam Parquet schema:
+**Quick biology primer**
 
-```text
-begin_of_sequence, end_of_sequence, begin_of_gene, end_of_gene, gene_type,
-species_type, strand, sequence, molecule_type, topology, taxonomy, record_id,
-start, end
-```
+DNA is the molecule that stores genetic information in all living things. It is a sequence of four letters — **A, T, G, C** — and a genome can be anywhere from thousands to billions of these letters long. Training a language model on DNA means treating those letters like tokens and learning the statistical patterns of life.
 
-The three OpenGenome2-derived configs have:
+This corpus covers three major layers of biological complexity:
+
+- **Eukaryotes** — organisms with a nucleus (animals, plants, fungi, protists). Complex, large genomes with introns, regulatory regions, and lots of repetition.
+- **Prokaryotes** — bacteria and archaea. Simpler, denser genomes; genes are packed tightly with less non-coding "junk."
+- **mRNA** — the processed, spliced transcript of a gene. This is what actually gets translated into protein. Much shorter than full genomic sequences. Including mRNA teaches the model about gene structure without the noise of intergenic regions.
 
-```text
-text, metadata
-```
 
-After scrubbing, `metadata` no longer contains local `/scratch/...` paths. It
-contains a compact upstream source filename, and for prokaryote rows may also
-include `record`.
+## Loading the data
 
-## Usage
 
 ```python
 from datasets import load_dataset
 
 ds = load_dataset(
     "hf-carbon/carbon-pretraining-corpus",
-    "mrna_evo2",
+    "mrna_evo2",          # or: eukaryote_generator | mrna_splice_evo2 | prokaryote_evo2
     split="train",
     streaming=True,
 )
-print(next(iter(ds)))
+
+for example in ds.take(3):
+    print(example)
 ```
 
-To stream the four configs together:
 
-```python
-from datasets import interleave_datasets, load_dataset
-
-configs = [
-    "eukaryote_generator",
-    "prokaryote_evo2",
-    "mrna_splice_evo2",
-    "mrna_evo2",
-]
-streams = [
-    load_dataset("hf-carbon/carbon-pretraining-corpus", cfg, split="train", streaming=True)
-    for cfg in configs
-]
-mixed = interleave_datasets(streams, seed=42)
+## Subset Details
+
+### 1. `eukaryote_generator` — Eukaryote Genomes
+
+**Source:** [GenerTeam/pretrain_data_eukaryote](https://huggingface.co/datasets/GenerTeam/pretrain_data_eukaryote) · MIT License
+
+**What it contains:** Genomic sequences from eukaryotic organisms (fungi, plants, animals, and more), packaged by the GenerTeam as part of their [GENERATOR](https://arxiv.org/abs/2502.07272) genomic foundation model. This is the main part is Carbon training data, which is focused on Eukaryote species. Each row carries full taxonomic metadata, gene type, strand orientation, and chromosome coordinates alongside the raw sequence. 
+We filter out sequences longer than 100 kbp, as excluding them improves training performance on DNA donwstream benchmarks. For long-context training, you can concatenate genes from the same contig to build longer samples.
+
+**Schema:**
+
+```
+begin_of_sequence   bool     — special boundary marker
+end_of_sequence     bool     — special boundary marker
+begin_of_gene       bool     — marks gene start
+end_of_gene         bool     — marks gene end
+gene_type           str      — e.g. "protein_coding", "ncRNA", "pseudogene"
+species_type        str      — e.g. "fungi", "plant", "vertebrate"
+strand              str      — "+" or "-" (which DNA strand)
+sequence            str      — the raw nucleotide string (A/T/G/C/N...)
+molecule_type       str      — e.g. "genomic DNA"
+topology            str      — "linear" or "circular"
+taxonomy            str      — full NCBI taxonomy lineage
+record_id           str      — upstream GenBank/RefSeq accession
+start               int      — coordinate start on chromosome
+end                 int      — coordinate end on chromosome
+```
+
+**Example row (sequence truncated):**
+```json
+{
+  "species_type": "fungi",
+  "gene_type": "protein_coding",
+  "strand": "+",
+  "sequence": "ATGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC...",
+  "taxonomy": "Eukaryota; Fungi; Ascomycota; ...",
+  "record_id": "NC_001224.1",
+  "start": 1872,
+  "end": 3503
+}
 ```
 
-Pass `probabilities=` to `interleave_datasets` if you want to reproduce a
-specific training mixture.
+### 2. `mrna_evo2` — Messenger RNA Sequences
 
-## Provenance
+**Source:** [arcinstitute/opengenome2](https://huggingface.co/datasets/arcinstitute/opengenome2) · Apache-2.0 License · `mrna` split
 
-This mirror is derived from:
+**What it contains:** Processed mRNA sequences — the "final edited" version of a gene after the cell has removed introns (non-coding interruptions) and kept only the exons. This is the sequence that gets read to produce protein. These sequences are shorter and more information-dense than raw genomic DNA.
 
-- [GenerTeam/pretrain_data_eukaryote](https://huggingface.co/datasets/GenerTeam/pretrain_data_eukaryote), MIT license.
-- [arcinstitute/opengenome2](https://huggingface.co/datasets/arcinstitute/opengenome2), Apache-2.0 license.
+**Schema:**
+```
+text        str   — the raw nucleotide sequence
+metadata    dict  — {"source": "data_mrna_train_chunk1.jsonl.gz", "record": "..."}
+```
 
-The OpenGenome2 configs include train chunks only:
+**Stats:** 52.7 M rows · mean 2,200 nt · min 64 nt · max ~100 K nt · 115.9 Gbp total
 
-- `json/pretraining_or_both_phases/mrna/*_train_*.jsonl.gz`
-- `json/pretraining_or_both_phases/mrna_splice_promoter/*_train_*.jsonl.gz`
-- `json/pretraining_or_both_phases/gtdb_v220_imgpr/*_train_*.jsonl.gz`
 
-## Limitations
+### 3. `mrna_splice_evo2` — Augmented mRNA Transcripts
 
-- This is a private pretraining mirror, not a benchmark dataset.
-- OpenGenome2 test chunks are intentionally omitted.
-- No additional deduplication or quality filtering was applied beyond upstream processing.
-- The configs are schema-asymmetric: `eukaryote_generator` has a rich structured schema, while OpenGenome2-derived configs are `text` plus `metadata`.
-- Sequence casing, ambiguity codes, and length distributions differ by upstream source.
+**Source:** [arcinstitute/opengenome2](https://huggingface.co/datasets/arcinstitute/opengenome2) · Apache-2.0 · `mrna_splice_promoter` split
 
-## Citation
+**What it contains:** The same mRNA transcripts as `mrna_evo2`, with augmentations applied by the Evo2 team: each transcript gets an extra 1,024 bp of upstream promoter sequence prepended, and an extra 32 bp of flanking sequence around each exon boundary to expose splice sites. The resulting exon chunks are concatenated with a special `@` separator into a single stitched sequence per transcript.
 
-If you use this mirror, cite the upstream datasets:
+Sequences here are systematically longer than `mrna_evo2` — the extra promoter and splice flanks are the only difference, not a different set of genes.
 
-```bibtex
-@misc{generteam2025generator,
-  title        = {GENERATOR: A Long-Context Generative Genomic Foundation Model},
-  author       = {GenerTeam},
-  year         = {2025},
-  eprint       = {2502.07272},
-  archivePrefix= {arXiv},
-}
+**Stats:** 56.9 M rows · mean 3,470 nt · min 96 nt · max ~122 K nt · 197.4 Gbp total
 
-@misc{arcinstitute_opengenome2,
-  title        = {OpenGenome2},
-  author       = {Arc Institute},
-  howpublished = {Hugging Face dataset: arcinstitute/opengenome2},
-}
+### 4. `prokaryote_evo2` — Prokaryote Genomes (Bacteria & Archaea)
+
+**Upstream:** [arcinstitute/opengenome2](https://huggingface.co/datasets/arcinstitute/opengenome2) · Apache-2.0 License · `gtdb_v220_imgpr` split
+
+**What it contains:** Long chromosomal chunks from bacteria and archaea, sourced from [GTDB v220](https://gtdb.ecogenomic.org/) (a curated taxonomy of ~85 K prokaryote genomes) and [IMG/PR](https://img.jgi.doe.gov/) (a DOE database of environmental prokaryote sequences). Prokaryote genomes are compact — genes sit back-to-back with minimal intergenic space — so these sequences are biologically rich per nucleotide.
+
+**Schema:** identical to the mRNA subsets
 ```
+text        str   — nucleotide sequence (can be megabases long)
+metadata    dict  — {"source": "gtdb_..._train_chunk1.jsonl.gz", "record": "GCF_..."}
+```
+
+**Stats:** 17.4 M rows · mean 20,533 nt · min 20 nt · **max ~16 M nt** · 357.5 Gbp total
+
+
+## ⚗️ Carbon Training Mixture
+
+The proportions below reflect the target mixture for Carbon's pure-DNA pretraining runs (1 T token target):
+
+| Subset | Approx. weight |
+|---|---:|
+| `prokaryote_evo2` | ~70% |
+| `mrna_splice_evo2` | ~15% |
+| `mrna_evo2` | ~10% |
+| `eukaryote_generator` | ~5% |
+
+
+### Metadata conditioning in Carnon training (`eukaryote_generator` only)
+
+In Carbon we added optional metadata tags to a fraction of eukaryote sequences, so the model learns to use biological context when available but doesn't depend on it. Tags are prepended before the sequence with random dropout at tokenization time:
+
+```text
+# 50% of sequences — no tags
+<dna>ATGCTAGCTA...</dna>
+
+# 16.7% — species + gene type
+<species>fungi<gene_type>protein_coding<dna>ATGCTAGCTA...</dna>
+
+# 16.7% — species only
+<species>fungi<dna>ATGCTAGCTA...</dna>
+
+# 16.7% — gene type only
+<gene_type>protein_coding<dna>ATGCTAGCTA...</dna>
+```
+
+At inference time you can prompt with any combination of tags or none at all. The three OpenGenome2 subsets are tokenized as plain `<dna>SEQUENCE</dna>` without metadata conditioning.