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 # mutation, insertion, deletion 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(sequence)-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"}, "paired-42": {"train": "https://huggingface.co/datasets/thewall/Simulation/resolve/main/data/paired-42-train.parquet", "test": "https://huggingface.co/datasets/thewall/Simulation/resolve/main/data/paired-42-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 # if "paired" in kwargs['name']: # 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, 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), SimulationConfig(name="paired-42", n_seq=10000, 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 # splited_data = dataset.train_test_split(train_size=0.9, seed=666) # splited_data['train'].to_parquet("paired-666-train.parquet") # splited_data['test'].to_parquet("paired-666-test.parquet") # dataset = load_dataset(path = "thewall/simulation", name="multiple", split="all") # splited_data = dataset.train_test_split(train_size=0.9, seed=666) # splited_data['train'].to_parquet("multiple-666-train.parquet") # splited_data['test'].to_parquet("multiple-666-test.parquet") dataset = load_dataset("simulation.py", name="paired-666", split="test")