Datasets:

drake463
/

FireProtDB2

@@ -1,339 +0,0 @@
-# fireprotdb.py
-from __future__ import annotations
-import hashlib
-from dataclasses import dataclass
-from typing import Dict, List, Optional
-import datasets
-# Change these when publishing:
-_CITATION = """\
-@misc{fireprotdb2,
-  title = {FireProtDB 2.0},
-  note  = {See original FireProtDB 2.0 publication and ProTherm sources}
-}
-"""
-_DESCRIPTION = """\
-ML-ready views of FireProtDB 2.0 derived from the raw CSV:
-- mutation-level regression/classification (ddg, dtm, stabilizing)
-- protein-level aggregated landscape view
-- mutation language modeling view
-This dataset is intended for Rosetta Commons / protein ML benchmarking.
-"""
-_HOMEPAGE = "https://huggingface.co/datasets/drake463/FireProtDB"  # update
-_LICENSE = "cc-by-4.0"  # update to correct license if different
-# If you publish to HF, include the cleaned parquet in the repo and set this relative path.
-# For local testing, replace with your local path.
-_DEFAULT_DATA_FILE = "data/fireportdb_cleaned.parquet"
-class FireProtDBConfig(datasets.BuilderConfig):
-    def __init__(self, task: str, **kwargs):
-        super().__init__(**kwargs)
-        self.task = task
-_BUILDER_CONFIGS = [
-    FireProtDBConfig(
-        name="mutation_ddg",
-        version=datasets.Version("1.0.0"),
-        description="Mutation-level ΔΔG regression (row-per-experiment where ddg present).",
-        task="mutation_ddg",
-    ),
-    FireProtDBConfig(
-        name="mutation_dtm",
-        version=datasets.Version("1.0.0"),
-        description="Mutation-level ΔTm regression (row-per-experiment where dtm present).",
-        task="mutation_dtm",
-    ),
-    FireProtDBConfig(
-        name="mutation_binary",
-        version=datasets.Version("1.0.0"),
-        description="Mutation-level binary stability classification (explicit stabilizing or ddg-sign-derived).",
-        task="mutation_binary",
-    ),
-    FireProtDBConfig(
-        name="mutation_lm",
-        version=datasets.Version("1.0.0"),
-        description="Mutation language-modeling view: (sequence, mutation, position, target_aa).",
-        task="mutation_lm",
-    ),
-    FireProtDBConfig(
-        name="protein_landscape",
-        version=datasets.Version("1.0.0"),
-        description="Protein-level aggregated landscapes: one row per protein with list of variants.",
-        task="protein_landscape",
-    ),
-]
-def _stable_hash(s: str) -> int:
-    h = hashlib.sha256(s.encode("utf-8")).hexdigest()
-    return int(h[:8], 16)
-def _split_by_protein(uniprot: Optional[str], sequence_id: Optional[str], ratios=(0.8, 0.1, 0.1)) -> str:
-    """
-    Deterministic protein-level split using (uniprotkb if present else sequence_id).
-    """
-    key = (uniprot or "").strip()
-    if not key:
-        key = f"seqid:{(sequence_id or '').strip()}"
-    if not key.strip():
-        key = "unknown"
-    r = _stable_hash(key) / 0xFFFFFFFF
-    if r < ratios[0]:
-        return "train"
-    if r < ratios[0] + ratios[1]:
-        return "validation"
-    return "test"
-class FireProtDB(datasets.GeneratorBasedBuilder):
-    BUILDER_CONFIGS = _BUILDER_CONFIGS
-    DEFAULT_CONFIG_NAME = "mutation_ddg"
-    def _info(self) -> datasets.DatasetInfo:
-        # Base schema for mutation-level records
-        mutation_features = datasets.Features(
-            {
-                "experiment_id": datasets.Value("string"),
-                "sequence_id": datasets.Value("string"),
-                "uniprotkb": datasets.Value("string"),
-                "protein_name": datasets.Value("string"),
-                "organism": datasets.Value("string"),
-                "sequence_length": datasets.Value("int32"),
-                "mutation": datasets.Value("string"),
-                "wt_residue": datasets.Value("string"),
-                "position": datasets.Value("int32"),
-                "mut_residue": datasets.Value("string"),
-                "ddg": datasets.Value("float32"),
-                "dtm": datasets.Value("float32"),
-                "tm": datasets.Value("float32"),
-                "ph": datasets.Value("float32"),
-                "buffer": datasets.Value("string"),
-                "method": datasets.Value("string"),
-                "measure": datasets.Value("string"),
-                "pmid": datasets.Value("string"),
-                "doi": datasets.Value("string"),
-                "publication_year": datasets.Value("int32"),
-                "split": datasets.ClassLabel(names=["train", "validation", "test"]),
-				"pdb_id": datasets.Value("string"),
-				"pdb_ids": datasets.Sequence(datasets.Value("string")),
-            }
-        )
-        if self.config.task == "mutation_lm":
-            features = datasets.Features(
-                {
-                    "experiment_id": datasets.Value("string"),
-                    "sequence_id": datasets.Value("string"),
-                    "uniprotkb": datasets.Value("string"),
-                    "sequence": datasets.Value("string"),  # optional if you later join sequences
-                    "mutation": datasets.Value("string"),
-                    "position": datasets.Value("int32"),
-                    "target_aa": datasets.Value("string"),
-                    "split": datasets.ClassLabel(names=["train", "validation", "test"]),
-                }
-            )
-        elif self.config.task == "protein_landscape":
-            features = datasets.Features(
-                {
-                    "protein_key": datasets.Value("string"),
-                    "uniprotkb": datasets.Value("string"),
-                    "sequence_id": datasets.Value("string"),
-                    "protein_name": datasets.Value("string"),
-                    "organism": datasets.Value("string"),
-                    "sequence_length": datasets.Value("int32"),
-                    "variants": datasets.Sequence(
-                        {
-                            "experiment_id": datasets.Value("string"),
-                            "mutation": datasets.Value("string"),
-                            "position": datasets.Value("int32"),
-                            "wt_residue": datasets.Value("string"),
-                            "mut_residue": datasets.Value("string"),
-                            "ddg": datasets.Value("float32"),
-                            "dtm": datasets.Value("float32"),
-                            "ph": datasets.Value("float32"),
-                            "buffer": datasets.Value("string"),
-                            "method": datasets.Value("string"),
-							"pdb_id": datasets.Value("string"),
-							"pdb_ids": datasets.Sequence(datasets.Value("string")),
-                        }
-                    ),
-                    "split": datasets.ClassLabel(names=["train", "validation", "test"]),
-                }
-            )
-        else:
-            features = mutation_features
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            homepage=_HOMEPAGE,
-            license=_LICENSE,
-            citation=_CITATION,
-        )
-    def _split_generators(self, dl_manager: datasets.DownloadManager):
-        # You can also host the cleaned file and put a URL here.
-        data_path = dl_manager.download(_DEFAULT_DATA_FILE)
-        # We'll generate ALL examples in one pass and assign split label per protein_key.
-        return [
-            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"path": data_path, "wanted_split": "train"}),
-            datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"path": data_path, "wanted_split": "validation"}),
-            datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"path": data_path, "wanted_split": "test"}),
-        ]
-    def _generate_examples(self, path: str, wanted_split: str):
-        import pandas as pd
-        # Read cleaned canonical table
-        if path.endswith(".parquet"):
-            df = pd.read_parquet(path)
-        else:
-            df = pd.read_csv(path)
-        # Ensure types
-        # (pandas nullable ints may appear; keep safe casting below)
-        def _to_int(x):
-            try:
-                return int(x)
-            except Exception:
-                return None
-        def _to_float(x):
-            try:
-                return float(x)
-            except Exception:
-                return None
-        # Task-specific filtering and shaping
-        if self.config.task in ("mutation_ddg", "mutation_binary", "mutation_lm"):
-            df_task = df[df["mutation"].notna()].copy()
-        elif self.config.task == "mutation_dtm":
-            df_task = df[df["mutation"].notna()].copy()
-        elif self.config.task == "protein_landscape":
-            df_task = df[df["mutation"].notna()].copy()
-        else:
-            df_task = df.copy()
-        # Apply label availability filters
-        if self.config.task == "mutation_ddg":
-            df_task = df_task[df_task["ddg"].notna()]
-        elif self.config.task == "mutation_dtm":
-            df_task = df_task[df_task["dtm"].notna()]
-        elif self.config.task == "mutation_binary":
-            df_task = df_task[df_task["stabilizing"].notna()]
-        elif self.config.task == "mutation_lm":
-            # Needs position and mut_residue for target_aa
-            df_task = df_task[df_task["position"].notna() & df_task["mut_residue"].notna()]
-        # Assign protein-level split deterministically
-        def protein_split(row) -> str:
-            return _split_by_protein(
-                uniprot=str(row.get("uniprotkb") or "").strip() or None,
-                sequence_id=str(row.get("sequence_id") or "").strip() or None,
-            )
-        df_task["split_name"] = df_task.apply(protein_split, axis=1)
-        df_task = df_task[df_task["split_name"] == wanted_split]
-        if self.config.task == "protein_landscape":
-            # Aggregate into one row per protein_key (uniprot preferred)
-            def protein_key(row) -> str:
-                u = str(row.get("uniprotkb") or "").strip()
-                if u:
-                    return u
-                sid = str(row.get("sequence_id") or "").strip()
-                return f"seqid:{sid}" if sid else "unknown"
-            df_task["protein_key"] = df_task.apply(protein_key, axis=1)
-            grouped = df_task.groupby("protein_key", dropna=False)
-            idx = 0
-            for pk, g in grouped:
-                # Representative metadata
-                first = g.iloc[0]
-                record = {
-                    "protein_key": str(pk),
-                    "uniprotkb": str(first.get("uniprotkb") or ""),
-                    "sequence_id": str(first.get("sequence_id") or ""),
-                    "protein_name": str(first.get("protein_name") or ""),
-                    "organism": str(first.get("organism") or ""),
-                    "sequence_length": _to_int(first.get("sequence_length")) or 0,
-                    "variants": [],
-                    "split": wanted_split,
-                }
-                for _, r in g.iterrows():
-                    record["variants"].append(
-                        {
-                            "experiment_id": str(r.get("experiment_id") or ""),
-                            "mutation": str(r.get("mutation") or ""),
-                            "position": _to_int(r.get("position")) or -1,
-                            "wt_residue": str(r.get("wt_residue") or ""),
-                            "mut_residue": str(r.get("mut_residue") or ""),
-                            "ddg": _to_float(r.get("ddg")),
-                            "dtm": _to_float(r.get("dtm")),
-                            "ph": _to_float(r.get("ph")),
-                            "buffer": str(r.get("buffer_norm") or r.get("buffer_raw") or ""),
-                            "method": str(r.get("method_norm") or ""),
-							"pdb_id": str(r.get("pdb_id") or ""),
-							"pdb_ids": list(r.get("pdb_ids") or []),
-                        }
-                    )
-                yield idx, record
-                idx += 1
-            return
-        # Mutation LM view
-        if self.config.task == "mutation_lm":
-            for i, r in df_task.reset_index(drop=True).iterrows():
-                yield i, {
-                    "experiment_id": str(r.get("experiment_id") or ""),
-                    "sequence_id": str(r.get("sequence_id") or ""),
-                    "uniprotkb": str(r.get("uniprotkb") or ""),
-                    "sequence": "",  # left blank unless you join real sequences elsewhere
-                    "mutation": str(r.get("mutation") or ""),
-                    "position": _to_int(r.get("position")) or -1,
-                    "target_aa": str(r.get("mut_residue") or ""),
-                    "split": wanted_split,
-                }
-            return
-        # Standard mutation-level views
-        for i, r in df_task.reset_index(drop=True).iterrows():
-            yield i, {
-                "experiment_id": str(r.get("experiment_id") or ""),
-                "sequence_id": str(r.get("sequence_id") or ""),
-                "uniprotkb": str(r.get("uniprotkb") or ""),
-                "protein_name": str(r.get("protein_name") or ""),
-                "organism": str(r.get("organism") or ""),
-                "sequence_length": _to_int(r.get("sequence_length")) or 0,
-                "mutation": str(r.get("mutation") or ""),
-                "wt_residue": str(r.get("wt_residue") or ""),
-                "position": _to_int(r.get("position")) or -1,
-                "mut_residue": str(r.get("mut_residue") or ""),
-                "ddg": _to_float(r.get("ddg")),
-                "dtm": _to_float(r.get("dtm")),
-                "tm": _to_float(r.get("tm")),
-                "ph": _to_float(r.get("ph")),
-                "buffer": str(r.get("buffer_norm") or r.get("buffer_raw") or ""),
-                "method": str(r.get("method_norm") or ""),
-                "measure": str(r.get("measure_norm") or ""),
-                "pmid": str(r.get("pmid") or ""),
-                "doi": str(r.get("doi") or ""),
-				"pdb_id": str(r.get("pdb_id") or ""),
-				"pdb_ids": list(r.get("pdb_ids") or []),
-                "publication_year": int(r.get("publication_year")) if str(r.get("publication_year") or "").isdigit() else 0,
-                "split": wanted_split,
-            }