| 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.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 |
| |
| error_types = np.random.choice(SNV, size=n) |
| sequences = [] |
| valid_masks = [] |
| 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] |
| mask = [1]*len(motif) |
| if has_error: |
| if error_type == SNV.Mutation: |
| seq[self.mut_idx] = self.mutate(seq[self.mut_idx]) |
| mask[self.mut_idx] = 0 |
| elif error_type == SNV.Insertion: |
| seq[self.ins_idx] = np.random.choice( |
| list("ATGC")) + seq[self.ins_idx] |
| mask.insert(self.ins_idx, 0) |
| elif error_type == SNV.Deletion: |
| seq[self.del_idx] = "" |
| del mask[self.del_idx] |
| else: |
| raise NotImplementedError |
| seq = "".join(seq) |
| sequences.append(seq) |
| valid_masks.append(mask) |
| return sequences, valid_masks, motif_indices.tolist() |
|
|
| def sample(self, n=1, with_indices=True): |
| motifs, valid_masks, motif_indices = self.sample_motif(n) |
| sequences = [] |
| motif_masks = [] |
| paired_indices = [] |
| for seq, mask in zip(motifs, valid_masks): |
| if self.paired: |
| seq, mask, idx = self.insert_in_the_middle( |
| seq, mask, 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) |
| motif_masks.append([0]*(len(self.forward_primer)+l)+mask+[0]*(len(random_region)-l+len(self.reverse_primer))) |
| else: |
| sequences.append(random_region[:l] + seq + random_region[l:]) |
| motif_masks.append([0]*l+mask+[0]*(len(random_region)-l)) |
|
|
| if self.paired and with_indices: |
| return sequences, motif_masks, motif_indices, paired_indices |
| elif with_indices: |
| return sequences, motif_masks, motif_indices |
| return sequences, motif_masks |
|
|
| def insert_in_the_middle(self, sequence, mask, 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 |
| seq = l_motif + "".join(np.random.choice(list("ATGC"), size=n)) + r_motif |
| new_mask = mask[:len(l_motif)]+[0]*n+mask[-len(r_motif):] |
| return seq, new_mask, idx |
|
|
|
|
| DATA_FILES = {"multiple-666": {"train": "https://huggingface.co/datasets/thewall/Simulation/resolve/main/data/multiple-666-train.parquet", |
| "test": "https://huggingface.co/datasets/thewall/Simulation/resolve/main/data/multiple-666-test.parquet"}, |
| "paired-666": {"train": "https://huggingface.co/datasets/thewall/Simulation/resolve/main/data/paired-666-train.parquet", |
| "test": "https://huggingface.co/datasets/thewall/Simulation/resolve/main/data/paired-666-test.parquet"}, |
| } |
|
|
| class SimulationConfig(datasets.BuilderConfig): |
| def __init__(self, n_seq, num_motifs=1, motif_length=10, error_rate=0.0, seed=0, add_primer=False, paired=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 |
| self.paired = paired |
| |
| |
| |
| |
|
|
|
|
| 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, paired=True), |
| SimulationConfig(name="multiple-666", num_motifs=10, error_rate=0.1, n_seq=10000, seed=0), |
| SimulationConfig(name="paired-666", n_seq=5000, seed=0, paired=True), |
| ] |
|
|
| DEFAULT_CONFIG_NAME = "multiple-666" |
|
|
| def _info(self): |
| return datasets.DatasetInfo( |
| description=_DESCRIPTION, |
| features=datasets.Features( |
| { |
| "id": datasets.Value("int32"), |
| "seq": datasets.Value("string"), |
| "motif": datasets.Value("string"), |
| "motif_ids": datasets.Value("int32"), |
| "motif_mask": datasets.Sequence(feature=datasets.Value("int32")), |
| } |
| ), |
| homepage="https://github.com/hmdlab/raptgen/blob/master/raptgen/data.py", |
| citation=_CITATION, |
| ) |
|
|
| def _split_generators(self, dl_manager): |
| if self.config.name in DATA_FILES: |
| train_data_file = dl_manager.download(DATA_FILES[self.config.name]['train']) |
| test_data_file = dl_manager.download(DATA_FILES[self.config.name]['test']) |
| dataset = datasets.load_dataset("parquet", data_files={"train": train_data_file, |
| "test": test_data_file}) |
|
|
| train_iterator = self._iterator(dataset['train']) |
| test_iterator = self._iterator(dataset['test']) |
| return [ |
| datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"iterator_fn": train_iterator}), |
| datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"iterator_fn": test_iterator}), |
| ] |
| else: |
| 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, |
| "paired": self.config.paired |
| } |
| iterator = self._sample(**kwargs) |
|
|
| return [ |
| datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"iterator_fn": iterator}), |
| ] |
|
|
| def _sample(self, num_motifs, motif_length, error_rate, seed, add_primer, sample_num, paired): |
| simulator = SequenceGenerator(num_motifs=num_motifs, motif_length=motif_length, |
| error_rate=error_rate, seed=seed, |
| add_primer=add_primer, paired=paired) |
| data = simulator.sample(sample_num) |
| motifs = simulator.motifs |
| for key, (seq, mask, motif_ids, label) in enumerate(zip(data[0], data[1], data[2], data[-1])): |
| yield key, {"id": key, |
| "seq": seq, |
| "motif": motifs[motif_ids], |
| "motif_ids": label, |
| "motif_mask": mask, |
| } |
|
|
| def _iterator(self, dataset): |
| for row in dataset: |
| yield row['id'], row |
|
|
| def _generate_examples(self, iterator_fn): |
| yield from iterator_fn |
|
|
|
|
| if __name__=="__main__": |
| from datasets import load_dataset |
| |
| |
| |
|
|
| |
| |
| |
| |
| |
| dataset = load_dataset("simulation.py", name="paired-666", split="test") |
