Copy mid/pipeline from HuggingFaceBio/FineDNA-Mid@663538d

mid/pipeline/1_regex_filter.py

@@ -0,0 +1,107 @@
+"""Step 1: keep documents that contain DNA, using a regex.
+
+This is the V4 strict filter we ran on FineWeb-Edu, FinePDFs, PubMed Central, bioRxiv and Biostars. A document passes when:
+  - it mentions at least one molecular-biology keyword (dna, gene, primer, pcr, ...), and
+  - it contains a run of 15 or more nucleotide letters (A, T, C, G, U, N; any case) that
+      - uses at least 3 different letters, so "AAAAAAAAAAAAAAA" or "NNNN..." alone do not count, and
+      - is not inside curly braces, which in scraped text is usually LaTeX rather than a sequence.
+
+Run it with datatrove over any parquet dataset with a text column:
+
+    python 1_regex_filter.py --input hf://datasets/HuggingFaceFW/fineweb-edu/sample/10BT --output ./dna_regex/fineweb_edu
+"""
+import argparse
+import re
+
+from datatrove.data import Document
+from datatrove.executor import LocalPipelineExecutor
+from datatrove.pipeline.filters.base_filter import BaseFilter
+from datatrove.pipeline.readers import ParquetReader
+from datatrove.pipeline.writers import JsonlWriter
+from datatrove.pipeline.writers.disk_base import DiskWriter
+
+
+class DNAFilterV4Strict(BaseFilter):
+    """
+    Strict regex filter for high-confidence DNA/RNA sequences.
+
+    Requirements:
+    - 15+ base sequences
+    - 3+ unique bases
+    - Biological keywords present
+    - Not in LaTeX braces
+    """
+    name = "🧬 DNAFilterV4Strict"
+
+    def __init__(self, exclusion_writer: DiskWriter = None):
+        super().__init__(exclusion_writer)
+        self.bio_terms = {
+            'dna', 'rna', 'nucleotide', 'genome', 'gene',
+            'base pair', 'codon', 'primer', 'pcr', 'amplification',
+            'sequencing', 'nucleic acid', 'oligonucleotide', 'plasmid',
+            'transcription', 'translation', 'mrna', 'ribosome',
+            'trna', 'rrna', 'uracil'
+        }
+        self.min_keywords = 1
+        self.nucleotide_pattern = re.compile(r'[ATCGUN]{15,}', re.IGNORECASE)
+
+    def _has_mixed_bases(self, seq: str, min_unique: int = 3) -> bool:
+        """Check if sequence contains at least min_unique different bases."""
+        seq_upper = seq.upper()
+        unique_bases = set(c for c in seq_upper if c in 'ATCGUN')
+        return len(unique_bases) >= min_unique
+
+    def _is_in_braces(self, text: str, match_start: int, match_end: int) -> bool:
+        """Check if the match is inside curly braces (likely LaTeX)."""
+        before = text[max(0, match_start - 100):match_start]
+        after = text[match_end:min(len(text), match_end + 100)]
+        open_braces = before.count('{') - before.count('}')
+        if open_braces > 0 and '}' in after:
+            return True
+        return False
+
+    def filter(self, doc: Document) -> bool:
+        text = doc.text
+        text_lower = text.lower()
+
+        keyword_count = sum(1 for term in self.bio_terms if term in text_lower)
+        if keyword_count < self.min_keywords:
+            return False
+
+        matches = list(self.nucleotide_pattern.finditer(text))
+        if not matches:
+            return False
+
+        for match in matches:
+            seq = match.group()
+            if not self._has_mixed_bases(seq):
+                continue
+            if self._is_in_braces(text, match.start(), match.end()):
+                continue
+
+            doc.metadata["filter_type"] = "strict_regex"
+            doc.metadata["stage"] = 1
+            return True
+
+        return False
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser(description="Keep documents that contain DNA (V4 strict regex filter).")
+    ap.add_argument("--input", required=True, help="folder of parquet files, local or hf://datasets/...")
+    ap.add_argument("--output", required=True, help="where to write the kept documents as jsonl.gz")
+    ap.add_argument("--text_key", default="text", help="text column (PubMed Central uses article_text)")
+    ap.add_argument("--glob", default="**/*.parquet")
+    ap.add_argument("--tasks", type=int, default=8)
+    a = ap.parse_args()
+
+    LocalPipelineExecutor(
+        pipeline=[
+            ParquetReader(a.input, glob_pattern=a.glob, text_key=a.text_key),
+            DNAFilterV4Strict(),
+            JsonlWriter(a.output, compression="gzip"),
+        ],
+        tasks=a.tasks,
+        workers=a.tasks,
+        logging_dir=f"{a.output}/logs",
+    ).run()

mid/pipeline/2_p90_split.py

@@ -0,0 +1,58 @@
+"""Step 2: split the regex-filtered documents by how long their longest DNA sequence is.
+
+Every DNA "word" in a document is found with tag_dna_sequences: a whitespace-delimited token of at least 6 letters that
+is pure A/C/G/T, or IUPAC codes (12+ letters, at most 20% ambiguous), with surrounding punctuation and 5'/3' markers
+stripped. A document whose longest DNA word is at least 39 bp, the 90th percentile of that length across the regex
+data, goes to p90; everything else goes to rest. Short DNA words are mostly primers and motifs; p90 documents carry
+real sequences.
+
+    python 2_p90_split.py --input ./dna_regex/fineweb_edu --p90 ./p90/fineweb_edu --rest ./rest/fineweb_edu
+
+Input and output are jsonl.gz files with a "text" field, as written by step 1. One output file per input file.
+"""
+import argparse
+import glob
+import gzip
+import json
+import os
+
+from tag_dna_sequences import tag_dna_sequences
+
+P90_THRESHOLD = 39  # bp: the 90th percentile of the longest DNA word per document
+MIN_LEN = 6         # bp: shortest token counted as DNA
+
+
+def longest_dna(text: str) -> int:
+    _, _, seqs = tag_dna_sequences(text, min_len=MIN_LEN)
+    return max((len(s) for s in seqs), default=0)
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Split DNA-bearing documents into p90 (longest DNA >= 39 bp) and rest.")
+    ap.add_argument("--input", required=True, help="folder of jsonl.gz files from step 1")
+    ap.add_argument("--p90", required=True, help="output folder for p90 documents")
+    ap.add_argument("--rest", required=True, help="output folder for the rest")
+    ap.add_argument("--threshold", type=int, default=P90_THRESHOLD)
+    a = ap.parse_args()
+
+    os.makedirs(a.p90, exist_ok=True)
+    os.makedirs(a.rest, exist_ok=True)
+    n_p90 = n_rest = 0
+    for path in sorted(glob.glob(os.path.join(a.input, "**", "*.jsonl.gz"), recursive=True)):
+        name = os.path.basename(path)
+        with gzip.open(path, "rt", encoding="utf-8") as fin, \
+             gzip.open(os.path.join(a.p90, name), "wt", encoding="utf-8") as fp90, \
+             gzip.open(os.path.join(a.rest, name), "wt", encoding="utf-8") as frest:
+            for line in fin:
+                if not line.strip():
+                    continue
+                text = json.loads(line).get("text") or ""
+                if longest_dna(text) >= a.threshold:
+                    fp90.write(line if line.endswith("\n") else line + "\n"); n_p90 += 1
+                else:
+                    frest.write(line if line.endswith("\n") else line + "\n"); n_rest += 1
+    print(f"p90: {n_p90:,} documents   rest: {n_rest:,} documents")
+
+
+if __name__ == "__main__":
+    main()

mid/pipeline/README.md

@@ -0,0 +1,41 @@
+# How the FineDNA biology text was found
+
+The `bio_*` subsets of FineDNA are web pages, papers and forum posts that contain DNA sequences inside normal text.
+They were found in two steps.
+
+## 1. Regex filter: does the document contain DNA? (`1_regex_filter.py`)
+
+We ran this filter over FineWeb-Edu, FinePDFs, PubMed Central, bioRxiv and Biostars. A document is kept when it
+
+- contains a run of **15 or more nucleotide letters** (A, T, C, G, U, N, any case),
+- that run uses **at least 3 different letters**, so `AAAAAAAAAAAAAAA` does not count,
+- the run is **not inside curly braces**, which in scraped text is usually LaTeX, and
+- the document mentions **at least one molecular-biology keyword**: dna, rna, nucleotide, genome, gene, base pair,
+  codon, primer, pcr, amplification, sequencing, nucleic acid, oligonucleotide, plasmid, transcription,
+  translation, mrna, ribosome, trna, rrna or uracil.
+
+```bash
+python 1_regex_filter.py --input hf://datasets/HuggingFaceFW/fineweb-edu/sample/10BT --output ./dna_regex/fineweb_edu
+```
+
+## 2. p90 split: how long is the DNA? (`2_p90_split.py`)
+
+Many regex hits are short: a primer, a restriction site, a motif. Training on documents with real sequences worked
+better, so we measure the **longest DNA word** in each document with `tag_dna_sequences.py`: a whitespace-delimited
+token of at least 6 letters that is pure A/C/G/T (or IUPAC codes, 12+ letters, at most 20% ambiguous), with
+punctuation and 5'/3' markers stripped.
+
+- Longest DNA word **at least 39 bp** (the 90th percentile across the regex data): `bio_p90_*`.
+- Everything else: `bio_rest`.
+
+```bash
+python 2_p90_split.py --input ./dna_regex/fineweb_edu --p90 ./p90/fineweb_edu --rest ./rest/fineweb_edu
+```
+
+In the Carbon-X mix, p90 gets as much weight as all of `bio_rest` and is read about seven times; `bio_rest` about
+twice.
+
+## Requirements
+
+`pip install datatrove` for step 1. Step 2 needs only the Python standard library and `tag_dna_sequences.py`, which
+sits next to it.

mid/pipeline/tag_dna_sequences.py

@@ -0,0 +1,183 @@
+import re
+from typing import List, Tuple, Dict, Any, Optional
+
+DNA_TOKEN_RE = re.compile(r"^[ATCGatcg]{6,}$")
+DNA_IUPAC_RE = re.compile(r"^[ATCGNRYKMSWBDHVatcgnrykmswbdhv]{6,}$")
+# For probe/primer strings like 5′-6FAM-ATCG...-MGB-NFQ-3′, split only on dashes.
+DASH_SPLIT_RE = re.compile(r"([-–—])")
+# Leading/trailing punctuation/markers commonly seen around sequences:
+# includes slashes, backslashes, primes (ASCII + unicode), digits (e.g. 5' / 3'),
+# hyphens and unicode dashes.
+PUNCT_EDGE_RE = re.compile(r"^([\\/\(\[\{\"'`′0-9\-–—]*)(.*?)([\\/\)\]\}\"'`′0-9,\;:\.\!\?\-–—]*)$")
+
+
+def _truncate_to_k(seq: str, k: int = 6) -> str:
+    """Truncate sequence to the largest multiple of k that is <= len(seq)."""
+    return seq[: (len(seq) // k) * k]
+
+
+def tag_dna_sequences(
+    text: str,
+    min_len: int = 6,
+    max_ambig_frac: float = 0.2,
+    truncate_to_k: int = 0,
+) -> Tuple[str, List[int], List[str]]:
+    """
+    Tag DNA-like tokens in text with <dna>...</dna>.
+    Criteria:
+    - Token must be a single whitespace-delimited word (after stripping edge punctuation)
+    - Token must be only A/T/C/G (case-insensitive) OR IUPAC codes (len >= 12) with ambiguity <= max_ambig_frac
+    - Token length >= min_len
+
+    Args:
+        truncate_to_k: if > 0, truncate each tagged sequence to the nearest
+            multiple of k before wrapping. This avoids tokenizer A-padding for
+            sequences whose length is not a multiple of k (e.g. truncate_to_k=6
+            turns TGAGTACT→TGAGTA before tagging).
+
+    Returns:
+        tagged_text, dna_word_ids, dna_sequences
+        dna_word_ids are indices among non-whitespace tokens (0-based)
+    """
+    if not text:
+        return text, [], []
+
+    # Preserve original whitespace by splitting into tokens + separators
+    parts = re.split(r"(\s+)", text)
+
+    dna_word_ids: List[int] = []
+    dna_sequences: List[str] = []
+
+    word_index = 0
+    for i, part in enumerate(parts):
+        if not part or part.isspace():
+            continue
+
+        # Strip leading/trailing punctuation for matching only
+        lead, core, trail = part, part, ""
+        m = PUNCT_EDGE_RE.match(part)
+        if m:
+            lead, core, trail = m.group(1), m.group(2), m.group(3)
+
+        if core and len(core) >= min_len:
+            tagged_any = False
+
+            if DNA_TOKEN_RE.match(core):
+                core_up = core.upper()
+                if truncate_to_k > 0:
+                    core_up = _truncate_to_k(core_up, truncate_to_k)
+                if len(core_up) >= min_len:
+                    parts[i] = f"{lead}<dna>{core_up}</dna>{trail}"
+                    dna_sequences.append(core_up)
+                    tagged_any = True
+            elif DNA_IUPAC_RE.match(core):
+                core_up = core.upper()
+                ambig_count = sum(1 for c in core_up if c not in {"A", "T", "C", "G"})
+                ambig_frac = ambig_count / len(core_up)
+                if len(core_up) >= 12 and ambig_frac <= max_ambig_frac:
+                    if truncate_to_k > 0:
+                        core_up = _truncate_to_k(core_up, truncate_to_k)
+                    if len(core_up) >= min_len:
+                        parts[i] = f"{lead}<dna>{core_up}</dna>{trail}"
+                        dna_sequences.append(core_up)
+                        tagged_any = True
+            elif DASH_SPLIT_RE.search(core):
+                subparts = DASH_SPLIT_RE.split(core)
+                rebuilt = []
+                for sp in subparts:
+                    if not sp:
+                        continue
+                    if DASH_SPLIT_RE.fullmatch(sp):
+                        rebuilt.append(sp)
+                        continue
+                    if len(sp) < min_len:
+                        rebuilt.append(sp)
+                        continue
+                    if DNA_TOKEN_RE.match(sp):
+                        sp_up = sp.upper()
+                        if truncate_to_k > 0:
+                            sp_up = _truncate_to_k(sp_up, truncate_to_k)
+                        if len(sp_up) >= min_len:
+                            rebuilt.append(f"<dna>{sp_up}</dna>")
+                            dna_sequences.append(sp_up)
+                            tagged_any = True
+                        else:
+                            rebuilt.append(sp)
+                    elif DNA_IUPAC_RE.match(sp):
+                        sp_up = sp.upper()
+                        ambig_count = sum(1 for c in sp_up if c not in {"A", "T", "C", "G"})
+                        ambig_frac = ambig_count / len(sp_up)
+                        if len(sp_up) >= 12 and ambig_frac <= max_ambig_frac:
+                            if truncate_to_k > 0:
+                                sp_up = _truncate_to_k(sp_up, truncate_to_k)
+                            if len(sp_up) >= min_len:
+                                rebuilt.append(f"<dna>{sp_up}</dna>")
+                                dna_sequences.append(sp_up)
+                                tagged_any = True
+                            else:
+                                rebuilt.append(sp)
+                        else:
+                            rebuilt.append(sp)
+                    else:
+                        rebuilt.append(sp)
+                if tagged_any:
+                    parts[i] = f"{lead}{''.join(rebuilt)}{trail}"
+
+            if tagged_any:
+                dna_word_ids.append(word_index)
+
+        word_index += 1
+
+    return "".join(parts), dna_word_ids, dna_sequences
+
+
+def tag_dna_sequences_batch(
+    batch: Dict[str, List[str]],
+    text_key: str = "text",
+    min_len: int = 6,
+    max_ambig_frac: float = 0.2,
+) -> Dict[str, Any]:
+    texts = batch[text_key]
+    tagged_texts = []
+    all_ids = []
+    all_seqs = []
+
+    for text in texts:
+        tagged, ids, seqs = tag_dna_sequences(
+            text,
+            min_len=min_len,
+            max_ambig_frac=max_ambig_frac,
+        )
+        tagged_texts.append(tagged)
+        all_ids.append(ids)
+        all_seqs.append(seqs)
+
+    return {
+        f"{text_key}_tagged": tagged_texts,
+        "dna_word_ids": all_ids,
+        "dna_sequences": all_seqs,
+    }
+
+
+if __name__ == "__main__":
+    # Quick sanity tests (local, no dataset)
+    examples = [
+        "This is ATCGAT and ATCGATCG with words.",
+        "codon ATG should not be tagged if min_len=6.",
+        "lowercase atcgat should be tagged.",
+        r"T\. miR\148\F: \CAAGCACGAT TAGCATTTGA\; miR\148\R: \TAGAAAGCT TTCGAGACAA\.",
+        "5'ATCGATCG3' and 5′ATCGATCG3′ should be tagged.",
+        "Punctuation ATCGAT, should be tagged.",
+        "Probe 5′-6FAM-ATCGATCG-3′ should tag the DNA part.",
+        "Mix: ATCGATCG ATCGATx ATCGATCGAT",
+        "Multiple   spaces ATCGAT    and newlines\nATCGATCG",
+        "IUPAC ATCGNNRY should NOT be tagged at max_ambig_frac=0.2.",
+    ]
+
+    for ex in examples:
+        tagged, ids, seqs = tag_dna_sequences(ex, min_len=6)
+        print("---")
+        print("IN: ", ex)
+        print("OUT:", tagged)
+        print("IDS:", ids)
+        print("SEQ:", seqs)