📈Reformat with black

Author: ZDisket

examples/fastspeech2/extractfs_postnets.py

@@ -96,12 +96,12 @@ def main():
         os.makedirs(args.outdir)
 
     # load config
-    
-    outdpost = os.path.join(args.outdir,"postnets")
-    
+
+    outdpost = os.path.join(args.outdir, "postnets")
+
     if not os.path.exists(outdpost):
         os.makedirs(outdpost)
-    
+
     with open(args.config) as f:
         config = yaml.load(f, Loader=yaml.Loader)
     config.update(vars(args))
@@ -118,7 +118,9 @@ def main():
         charactor_query=char_query,
         charactor_load_fn=char_load_fn,
     )
-    dataset = dataset.create(batch_size=1) # force batch size to 1 otherwise it may miss certain files
+    dataset = dataset.create(
+        batch_size=1
+    )  # force batch size to 1 otherwise it may miss certain files
 
     # define model and load checkpoint
     fastspeech2 = TFFastSpeech2(
@@ -134,8 +136,9 @@ def main():
         mel_lens = data["mel_lengths"]
 
         # fastspeech inference.
-        masked_mel_before, masked_mel_after , duration_outputs, _, _ = fastspeech2(**data,training=True)
-        
+        masked_mel_before, masked_mel_after, duration_outputs, _, _ = fastspeech2(
+            **data, training=True
+        )
 
         # convert to numpy
         masked_mel_befores = masked_mel_before.numpy()

examples/multiband_melgan_hf/train_multiband_melgan_hf.py

@@ -115,13 +115,13 @@ def compile(self, gen_model, dis_model, gen_optimizer, dis_optimizer, pqmf):
 
     def compute_per_example_generator_losses(self, batch, outputs):
         """Compute per example generator losses and return dict_metrics_losses
-        Note that all element of the loss MUST has a shape [batch_size] and 
+        Note that all element of the loss MUST has a shape [batch_size] and
         the keys of dict_metrics_losses MUST be in self.list_metrics_name.
 
         Args:
             batch: dictionary batch input return from dataloader
             outputs: outputs of the model
-        
+
         Returns:
             per_example_losses: per example losses for each GPU, shape [B]
             dict_metrics_losses: dictionary loss.
@@ -172,7 +172,9 @@ def compute_per_example_generator_losses(self, batch, outputs):
             adv_loss /= i + 1
             gen_loss += self.config["lambda_adv"] * adv_loss
 
-            dict_metrics_losses.update({"adversarial_loss": adv_loss},)
+            dict_metrics_losses.update(
+                {"adversarial_loss": adv_loss},
+            )
 
         dict_metrics_losses.update({"gen_loss": gen_loss})
         dict_metrics_losses.update({"subband_spectral_convergence_loss": sub_sc_loss})
@@ -185,13 +187,13 @@ def compute_per_example_generator_losses(self, batch, outputs):
 
     def compute_per_example_discriminator_losses(self, batch, gen_outputs):
         """Compute per example discriminator losses and return dict_metrics_losses
-        Note that all element of the loss MUST has a shape [batch_size] and 
+        Note that all element of the loss MUST has a shape [batch_size] and
         the keys of dict_metrics_losses MUST be in self.list_metrics_name.
 
         Args:
             batch: dictionary batch input return from dataloader
             outputs: outputs of the model
-        
+
         Returns:
             per_example_losses: per example losses for each GPU, shape [B]
             dict_metrics_losses: dictionary loss.
@@ -400,7 +402,6 @@ def main():
     else:
         raise ValueError("Only npy are supported.")
 
-
     if args.postnets is True:
         mel_query = "*-postnet.npy"
         logging.info("Using postnets")
@@ -553,4 +554,3 @@ def main():
 
 if __name__ == "__main__":
     main()
-

examples/tacotron2/export_align.py

@@ -8,73 +8,73 @@
 import numpy as np
 from scipy.spatial.distance import cdist
 
+
 def safemkdir(dirn):
     if not os.path.isdir(dirn):
         os.mkdir(dirn)
-        
+
+
 from pathlib import Path
 
+
 def duration_to_alignment(in_duration):
     total_len = np.sum(in_duration)
     num_chars = len(in_duration)
 
-    attention = np.zeros(shape=(num_chars,total_len),dtype=np.float32)
+    attention = np.zeros(shape=(num_chars, total_len), dtype=np.float32)
     y_offset = 0
 
     for duration_idx, duration_val in enumerate(in_duration):
-        for y_val in range(0,duration_val):
+        for y_val in range(0, duration_val):
             attention[duration_idx][y_offset + y_val] = 1.0
-        
+
         y_offset += duration_val
-    
+
     return attention
 
 
-def rescale_alignment(in_alignment,in_targcharlen):
+def rescale_alignment(in_alignment, in_targcharlen):
     current_x = in_alignment.shape[0]
     x_ratio = in_targcharlen / current_x
     pivot_points = []
-    
-    zoomed = zoom(in_alignment,(x_ratio,1.0),mode="nearest")
 
-    for x_v in range(0,zoomed.shape[0]):
-        for y_v in range(0,zoomed.shape[1]):
+    zoomed = zoom(in_alignment, (x_ratio, 1.0), mode="nearest")
+
+    for x_v in range(0, zoomed.shape[0]):
+        for y_v in range(0, zoomed.shape[1]):
             val = zoomed[x_v][y_v]
             if val < 0.5:
                 val = 0.0
             else:
                 val = 1.0
-                pivot_points.append( (x_v,y_v) )
+                pivot_points.append((x_v, y_v))
 
             zoomed[x_v][y_v] = val
-            
-    
+
     if zoomed.shape[0] != in_targcharlen:
         print("Zooming didn't rshape well, explicitly reshaping")
-        zoomed.resize((in_targcharlen,in_alignment.shape[1]))
+        zoomed.resize((in_targcharlen, in_alignment.shape[1]))
 
     return zoomed, pivot_points
 
 
-def gather_dist(in_mtr,in_points):
-    #initialize with known size for fast
-    full_coords = [(0,0) for x in range(in_mtr.shape[0] * in_mtr.shape[1])]
+def gather_dist(in_mtr, in_points):
+    # initialize with known size for fast
+    full_coords = [(0, 0) for x in range(in_mtr.shape[0] * in_mtr.shape[1])]
     i = 0
     for x in range(0, in_mtr.shape[0]):
         for y in range(0, in_mtr.shape[1]):
-            full_coords[i] = (x,y)
+            full_coords[i] = (x, y)
             i += 1
-    
-    return cdist(full_coords, in_points,"euclidean")
-        
-        
+
+    return cdist(full_coords, in_points, "euclidean")
 
 
-def create_guided(in_align,in_pvt,looseness):
-    new_att = np.ones(in_align.shape,dtype=np.float32)
+def create_guided(in_align, in_pvt, looseness):
+    new_att = np.ones(in_align.shape, dtype=np.float32)
     # It is dramatically faster that we first gather all the points and calculate than do it manually
     # for each point in for loop
-    dist_arr = gather_dist(in_align,in_pvt)
+    dist_arr = gather_dist(in_align, in_pvt)
     # Scale looseness based on attention size. (addition works better than mul). Also divide by 100
     # because having user input 3.35 is nicer
     real_loose = (looseness / 100) * (new_att.shape[0] + new_att.shape[1])
@@ -85,57 +85,61 @@ def create_guided(in_align,in_pvt,looseness):
 
             closest_pvt = in_pvt[min_point_idx]
             distance = dist_arr[g_idx][min_point_idx] / real_loose
-            distance = np.power(distance,2) 
+            distance = np.power(distance, 2)
 
             g_idx += 1
-            
-            new_att[x,y] = distance
 
-    return np.clip(new_att,0.0,1.0)
+            new_att[x, y] = distance
+
+    return np.clip(new_att, 0.0, 1.0)
+
 
 def get_pivot_points(in_att):
     ret_points = []
     for x in range(0, in_att.shape[0]):
         for y in range(0, in_att.shape[1]):
-            if in_att[x,y] > 0.8:
-                ret_points.append((x,y))
+            if in_att[x, y] > 0.8:
+                ret_points.append((x, y))
     return ret_points
 
+
 def main():
-    parser = argparse.ArgumentParser(description="Postprocess durations to become alignments")
+    parser = argparse.ArgumentParser(
+        description="Postprocess durations to become alignments"
+    )
     parser.add_argument(
-      "--dump-dir",
-      default="dump",
-      type=str,
-      help="Path of dump directory",
+        "--dump-dir",
+        default="dump",
+        type=str,
+        help="Path of dump directory",
     )
     parser.add_argument(
-      "--looseness",
-      default=3.5,
-      type=float,
-      help="Looseness of the generated guided attention map. Lower values = tighter",
+        "--looseness",
+        default=3.5,
+        type=float,
+        help="Looseness of the generated guided attention map. Lower values = tighter",
     )
     args = parser.parse_args()
     dump_dir = args.dump_dir
-    dump_sets = ["train","valid"]
+    dump_sets = ["train", "valid"]
 
     for d_set in dump_sets:
-        full_fol = os.path.join(dump_dir,d_set)
-        align_path = os.path.join(full_fol,"alignments")
+        full_fol = os.path.join(dump_dir, d_set)
+        align_path = os.path.join(full_fol, "alignments")
 
-        ids_path = os.path.join(full_fol,"ids")
-        durations_path = os.path.join(full_fol,"durations")
+        ids_path = os.path.join(full_fol, "ids")
+        durations_path = os.path.join(full_fol, "durations")
 
         safemkdir(align_path)
 
         for duration_fn in tqdm(os.listdir(durations_path)):
             if not ".npy" in duration_fn:
-                 continue
-        
-            id_fn = duration_fn.replace("-durations","-ids")
+                continue
 
-            id_path = os.path.join(ids_path,id_fn)
-            duration_path = os.path.join(durations_path,duration_fn)
+            id_fn = duration_fn.replace("-durations", "-ids")
+
+            id_path = os.path.join(ids_path, id_fn)
+            duration_path = os.path.join(durations_path, duration_fn)
 
             duration_arr = np.load(duration_path)
             id_arr = np.load(id_path)
@@ -145,25 +149,20 @@ def main():
             align = duration_to_alignment(duration_arr)
 
             if align.shape[0] != id_true_size:
-                align, points = rescale_alignment(align,id_true_size)
+                align, points = rescale_alignment(align, id_true_size)
             else:
                 points = get_pivot_points(align)
-            
-            if len(points) == 0:
-                print("WARNING points are empty for",id_fn)
 
-            align = create_guided(align,points,args.looseness)
+            if len(points) == 0:
+                print("WARNING points are empty for", id_fn)
 
-            
-            align_fn = id_fn.replace("-ids","-alignment")
-            align_full_fn = os.path.join(align_path,align_fn)
-            
-            np.save(align_full_fn,align.astype("float32"))
-        
+            align = create_guided(align, points, args.looseness)
 
+            align_fn = id_fn.replace("-ids", "-alignment")
+            align_full_fn = os.path.join(align_path, align_fn)
 
+            np.save(align_full_fn, align.astype("float32"))
 
 
 if __name__ == "__main__":
     main()
-

examples/tacotron2/extract_postnets.py

@@ -135,7 +135,9 @@ def main():
         reduction_factor=config["tacotron2_params"]["reduction_factor"],
         use_fixed_shapes=True,
     )
-    dataset = dataset.create(allow_cache=True, batch_size=args.batch_size, drop_remainder=False)
+    dataset = dataset.create(
+        allow_cache=True, batch_size=args.batch_size, drop_remainder=False
+    )
 
     # define model and load checkpoint
     tacotron2 = TFTacotron2(
@@ -170,11 +172,11 @@ def main():
         alignment_historys = alignment_historys.numpy()
         post_mel_outputs = post_mel_outputs.numpy()
         mel_gt = mel_gt.numpy()
-        
-        outdpost = os.path.join(args.outdir,"postnets")
-            
+
+        outdpost = os.path.join(args.outdir, "postnets")
+
         if not os.path.exists(outdpost):
-          os.makedirs(outdpost)
+            os.makedirs(outdpost)
 
         for i, alignment in enumerate(alignment_historys):
             real_char_length = input_lengths[i].numpy()