Update simulation.py

simulation.py

@@ -31,7 +31,7 @@ class SNV(IntEnum):
 
 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),
+                 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)
 
@@ -76,31 +76,38 @@ class SequenceGenerator():
         # 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)
-        return sequences, motif_indices.tolist()
+            valid_masks.append(mask)
+        return sequences, valid_masks, motif_indices.tolist()
 
     def sample(self, n=1, with_indices=True):
-        motifs, motif_indices = self.sample_motif(n)
+        motifs, valid_masks, motif_indices = self.sample_motif(n)
         sequences = []
+        motif_masks = []
         paired_indices = []
-        for seq in motifs:
+        for seq, mask in zip(motifs, valid_masks):
             if self.paired:
-                seq, idx = self.insert_in_the_middle(
-                    seq, nrange=self.middle_insert_range, one_side_proba=self.one_side_proba)
+                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)))
@@ -108,16 +115,18 @@ class SequenceGenerator():
             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_indices, paired_indices
+            return sequences, motif_masks, motif_indices, paired_indices
         elif with_indices:
-            return sequences, motif_indices
-        return sequences
+            return sequences, motif_masks, motif_indices
+        return sequences, motif_masks
 
-    def insert_in_the_middle(self, sequence, nrange=(2, 6), one_side_proba=0.5):
+    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":
@@ -132,7 +141,9 @@ class SequenceGenerator():
             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
+        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
 
 
 
@@ -167,8 +178,9 @@ class Simulation(datasets.GeneratorBasedBuilder):
                 {
                     "id": datasets.Value("int32"),
                     "seq": datasets.Value("string"),
-                    "motif_ids": datasets.Value("int32"),
                     "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",
@@ -196,11 +208,12 @@ class Simulation(datasets.GeneratorBasedBuilder):
                                       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])):
+        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": motifs[motif_ids]
+                        "motif_mask": mask,
                         }
 
 
@@ -211,4 +224,7 @@ if __name__=="__main__":
     dataset = load_dataset("simulation.py", name="multiple", split="all")
     print(dataset)
 
+    # simulator = SequenceGenerator(num_motifs=10, error_rate=0.1, seed=0)
+    # data = simulator.sample(10000)
+