Upload simulation.py

simulation.py

@@ -0,0 +1,214 @@
+import os
+import numpy as np
+from enum import IntEnum
+import datasets
+
+
+logger = datasets.logging.get_logger(__name__)
+
+
+_CITATION = """\
+@article{iwano2022generative,
+  title={Generative aptamer discovery using RaptGen},
+  author={Iwano, Natsuki and Adachi, Tatsuo and Aoki, Kazuteru and Nakamura, Yoshikazu and Hamada, Michiaki},
+  journal={Nature Computational Science},
+  pages={1--9},
+  year={2022},
+  publisher={Nature Publishing Group}
+}
+"""
+
+_DESCRIPTION = """\
+https://github.com/hmdlab/raptgen/blob/master/raptgen/data.py
+"""
+
+
+class SNV(IntEnum):
+    Mutation = 0
+    Insertion = 1
+    Deletion = 2
+
+
+class SequenceGenerator():
+    def __init__(self, num_motifs=1, motif_length=10, motifs=None,
+                 target_length=20, fix_random_region_length=True, error_rate=0, generate_motifs=True, middle_insert_range=(2, 6),
+                 seed=0, add_primer=True, forward_primer="AAAAA", reverse_primer="GGGGG", one_side_proba=0.5, paired=False):
+        np.random.seed(seed)
+
+        if generate_motifs:
+            self.motifs = ["".join(np.random.choice(
+                list("ATGC"), motif_length)) for _ in range(num_motifs)]
+        else:
+            self.motifs = motifs
+
+        self.error_indices = 1 + \
+            np.argsort(np.random.random(size=motif_length-1))[:3]
+        self.mut_idx, self.ins_idx, self.del_idx = self.error_indices
+
+        logger.info(f"error rate is {error_rate*100:.1f}%")
+        for idx, motif in enumerate(self.motifs):
+            seq = [ch for ch in motif]
+            mut = self.mutate(seq[self.mut_idx])
+            if error_rate != 0:
+                seq[self.mut_idx] = f"[{seq[self.mut_idx]}>{mut}]"
+                seq[self.ins_idx] = f"[+]{seq[self.ins_idx]}"
+                seq[self.del_idx] = f"{seq[self.del_idx].lower()}"
+            seq = "".join(seq)
+            logger.info(f"motif {idx} is {seq}")
+
+        self.num_motifs = num_motifs
+        self.error_rate = error_rate
+        self.target_length = target_length
+        self.forward_primer = forward_primer
+        self.reverse_primer = reverse_primer
+        self.add_primer = add_primer
+
+        self.one_side_proba = one_side_proba
+        self.middle_insert_range = middle_insert_range
+        self.paired = paired
+
+    def mutate(self, char):
+        return "TGCA"["ATGC".index(char)]
+
+    def sample_motif(self, n):
+        motif_indices = np.random.randint(self.num_motifs, size=n)
+        has_errors = np.random.random(size=n) < self.error_rate
+        # mutation, insertion, deletion
+        error_types = np.random.choice(SNV, size=n)
+        sequences = []
+        for motif_index, has_error, error_type in zip(motif_indices, has_errors, error_types):
+            motif = self.motifs[motif_index]
+            seq = [ch for ch in motif]
+            if has_error:
+                if error_type == SNV.Mutation:
+                    seq[self.mut_idx] = self.mutate(seq[self.mut_idx])
+                elif error_type == SNV.Insertion:
+                    seq[self.ins_idx] = np.random.choice(
+                        list("ATGC")) + seq[self.ins_idx]
+                elif error_type == SNV.Deletion:
+                    seq[self.del_idx] = ""
+                else:
+                    raise NotImplementedError
+            seq = "".join(seq)
+            sequences.append(seq)
+        return sequences, motif_indices.tolist()
+
+    def sample(self, n=1, with_indices=True):
+        motifs, motif_indices = self.sample_motif(n)
+        sequences = []
+        paired_indices = []
+        for seq in motifs:
+            if self.paired:
+                seq, idx = self.insert_in_the_middle(
+                    seq, nrange=self.middle_insert_range, one_side_proba=self.one_side_proba)
+                paired_indices += [idx]
+            random_region = "".join(np.random.choice(
+                list("ATGC"), size=self.target_length-len(seq)))
+            l = np.random.randint(len(random_region))
+            if self.add_primer:
+                sequences.append(
+                    self.forward_primer + random_region[:l] + seq + random_region[l:] + self.reverse_primer)
+            else:
+                sequences.append(random_region[:l] + seq + random_region[l:])
+
+        if self.paired and with_indices:
+            return sequences, motif_indices, paired_indices
+        elif with_indices:
+            return sequences, motif_indices
+        return sequences
+
+    def insert_in_the_middle(self, sequence, nrange=(2, 6), one_side_proba=0.5):
+        n = np.random.randint(*nrange)
+        if np.random.random() < one_side_proba:
+            if np.random.choice(["l", "r"]) == "l":
+                l_motif = sequence[:len(sequence)//2]
+                r_motif = ""
+                idx = 1
+            else:
+                l_motif = ""
+                r_motif = sequence[len(sequence)//2:]
+                idx = 2
+        else:
+            l_motif = sequence[:len(sequence)//2]
+            r_motif = sequence[len(sequence)//2:]
+            idx = 0
+        return l_motif + "".join(np.random.choice(list("ATGC"), size=n)) + r_motif, idx
+
+
+
+class SimulationConfig(datasets.BuilderConfig):
+    def __init__(self, n_seq, num_motifs=1, motif_length=10, error_rate=0.0, seed=0, add_primer=False, **kwargs):
+        super(SimulationConfig, self).__init__(**kwargs)
+        self.n_seq = n_seq
+        self.num_motifs = num_motifs
+        self.motif_length = motif_length
+        self.error_rate = error_rate
+        self.seed = seed
+        self.add_primer = add_primer
+        if kwargs['name']=="paired":
+            self.paired = True
+        else:
+            self.paired = False
+
+
+class Simulation(datasets.GeneratorBasedBuilder):
+
+    BUILDER_CONFIGS = [
+        SimulationConfig(name="multiple", num_motifs=10, error_rate=0.1, n_seq=10000, seed=0),
+        SimulationConfig(name="paired", n_seq=5000, seed=0)
+    ]
+
+    DEFAULT_CONFIG_NAME = "multiple"
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "id": datasets.Value("int32"),
+                    "seq": datasets.Value("string"),
+                    "motif_ids": datasets.Value("int32"),
+                    "motif": datasets.Value("string"),
+                }
+            ),
+            homepage="https://github.com/hmdlab/raptgen/blob/master/raptgen/data.py",
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        # downloaded_files = dl_manager.download_and_extract(self.config.url)
+        gen_kwargs = {"num_motifs": self.config.num_motifs,
+                      "motif_length": self.config.motif_length,
+                      "error_rate": self.config.error_rate,
+                      "seed": self.config.seed,
+                      "add_primer": self.config.add_primer,
+                      "sample_num": self.config.n_seq
+                      }
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs=gen_kwargs),
+        ]
+
+    def _generate_examples(self, num_motifs, motif_length, error_rate, seed, add_primer, sample_num):
+        # """This function returns the examples in the raw (text) form."""
+        # logger.info("generating examples from = %s", filepath)
+        simulator = SequenceGenerator(num_motifs=num_motifs, motif_length=motif_length,
+                                      error_rate=error_rate, seed=seed,
+                                      add_primer=add_primer)
+        data = simulator.sample(sample_num)
+        motifs = simulator.motifs
+        for key, (seq, motif_ids, label) in enumerate(zip(data[0], data[1], data[-1])):
+            yield key, {"id": key,
+                        "seq": seq,
+                        "motif_ids": label,
+                        "motif": motifs[motif_ids]
+                        }
+
+
+if __name__=="__main__":
+    from datasets import load_dataset
+    dataset = load_dataset("simulation.py", name="paired", split="all")
+    print(dataset)
+    dataset = load_dataset("simulation.py", name="multiple", split="all")
+    print(dataset)
+
+