format with black and pylint 2.7.3

TTS/speaker_encoder/dataset.py

@@ -7,9 +7,19 @@ from torch.utils.data import Dataset
 
 
 class MyDataset(Dataset):
-    def __init__(self, ap, meta_data, voice_len=1.6, num_speakers_in_batch=64,
-                 storage_size=1, sample_from_storage_p=0.5, additive_noise=0,
-                 num_utter_per_speaker=10, skip_speakers=False, verbose=False):
+    def __init__(
+        self,
+        ap,
+        meta_data,
+        voice_len=1.6,
+        num_speakers_in_batch=64,
+        storage_size=1,
+        sample_from_storage_p=0.5,
+        additive_noise=0,
+        num_utter_per_speaker=10,
+        skip_speakers=False,
+        verbose=False,
+    ):
         """
         Args:
             ap (TTS.tts.utils.AudioProcessor): audio processor object.
@@ -28,7 +38,7 @@ class MyDataset(Dataset):
         self.ap = ap
         self.verbose = verbose
         self.__parse_items()
-        self.storage = queue.Queue(maxsize=storage_size*num_speakers_in_batch)
+        self.storage = queue.Queue(maxsize=storage_size * num_speakers_in_batch)
         self.sample_from_storage_p = float(sample_from_storage_p)
         self.additive_noise = float(additive_noise)
         if self.verbose:
@@ -69,11 +79,14 @@ class MyDataset(Dataset):
             if speaker_ in self.speaker_to_utters.keys():
                 self.speaker_to_utters[speaker_].append(path_)
             else:
-                self.speaker_to_utters[speaker_] = [path_, ]
+                self.speaker_to_utters[speaker_] = [
+                    path_,
+                ]
 
         if self.skip_speakers:
-            self.speaker_to_utters = {k: v for (k, v) in self.speaker_to_utters.items() if
-                                      len(v) >= self.num_utter_per_speaker}
+            self.speaker_to_utters = {
+                k: v for (k, v) in self.speaker_to_utters.items() if len(v) >= self.num_utter_per_speaker
+            }
 
         self.speakers = [k for (k, v) in self.speaker_to_utters.items()]
 
@@ -100,13 +113,9 @@ class MyDataset(Dataset):
     def __sample_speaker(self):
         speaker = random.sample(self.speakers, 1)[0]
         if self.num_utter_per_speaker > len(self.speaker_to_utters[speaker]):
-            utters = random.choices(
-                self.speaker_to_utters[speaker], k=self.num_utter_per_speaker
-            )
+            utters = random.choices(self.speaker_to_utters[speaker], k=self.num_utter_per_speaker)
         else:
-            utters = random.sample(
-                self.speaker_to_utters[speaker], self.num_utter_per_speaker
-            )
+            utters = random.sample(self.speaker_to_utters[speaker], self.num_utter_per_speaker)
         return speaker, utters
 
     def __sample_speaker_utterances(self, speaker):
@@ -160,7 +169,9 @@ class MyDataset(Dataset):
 
             # get a random subset of each of the wavs and convert to MFCC.
             offsets_ = [random.randint(0, wav.shape[0] - self.seq_len) for wav in wavs_]
-            mels_ = [self.ap.melspectrogram(wavs_[i][offsets_[i]: offsets_[i] + self.seq_len]) for i in range(len(wavs_))]
+            mels_ = [
+                self.ap.melspectrogram(wavs_[i][offsets_[i] : offsets_[i] + self.seq_len]) for i in range(len(wavs_))
+            ]
             feats_ = [torch.FloatTensor(mel) for mel in mels_]
 
             labels.append(labels_)

TTS/speaker_encoder/losses.py

@@ -16,14 +16,14 @@ class GE2ELoss(nn.Module):
             - init_w (float): defines the initial value of w in Equation (5) of [1]
             - init_b (float): definies the initial value of b in Equation (5) of [1]
         """
-        super(GE2ELoss, self).__init__()
+        super().__init__()
         # pylint: disable=E1102
         self.w = nn.Parameter(torch.tensor(init_w))
         # pylint: disable=E1102
         self.b = nn.Parameter(torch.tensor(init_b))
         self.loss_method = loss_method
 
-        print(' > Initialised Generalized End-to-End loss')
+        print(" > Initialised Generalized End-to-End loss")
 
         assert self.loss_method in ["softmax", "contrast"]
 
@@ -55,9 +55,7 @@ class GE2ELoss(nn.Module):
         for spkr_idx, speaker in enumerate(dvecs):
             cs_row = []
             for utt_idx, utterance in enumerate(speaker):
-                new_centroids = self.calc_new_centroids(
-                    dvecs, centroids, spkr_idx, utt_idx
-                )
+                new_centroids = self.calc_new_centroids(dvecs, centroids, spkr_idx, utt_idx)
                 # vector based cosine similarity for speed
                 cs_row.append(
                     torch.clamp(
@@ -99,14 +97,8 @@ class GE2ELoss(nn.Module):
             L_row = []
             for i in range(M):
                 centroids_sigmoids = torch.sigmoid(cos_sim_matrix[j, i])
-                excl_centroids_sigmoids = torch.cat(
-                    (centroids_sigmoids[:j], centroids_sigmoids[j + 1 :])
-                )
-                L_row.append(
-                    1.0
-                    - torch.sigmoid(cos_sim_matrix[j, i, j])
-                    + torch.max(excl_centroids_sigmoids)
-                )
+                excl_centroids_sigmoids = torch.cat((centroids_sigmoids[:j], centroids_sigmoids[j + 1 :]))
+                L_row.append(1.0 - torch.sigmoid(cos_sim_matrix[j, i, j]) + torch.max(excl_centroids_sigmoids))
             L_row = torch.stack(L_row)
             L.append(L_row)
         return torch.stack(L)
@@ -122,6 +114,7 @@ class GE2ELoss(nn.Module):
         L = self.embed_loss(dvecs, cos_sim_matrix)
         return L.mean()
 
+
 # adapted from https://github.com/clovaai/voxceleb_trainer/blob/master/loss/angleproto.py
 class AngleProtoLoss(nn.Module):
     """
@@ -134,15 +127,16 @@ class AngleProtoLoss(nn.Module):
             - init_w (float): defines the initial value of w
             - init_b (float): definies the initial value of b
     """
+
     def __init__(self, init_w=10.0, init_b=-5.0):
-        super(AngleProtoLoss, self).__init__()
+        super().__init__()
         # pylint: disable=E1102
         self.w = nn.Parameter(torch.tensor(init_w))
         # pylint: disable=E1102
         self.b = nn.Parameter(torch.tensor(init_b))
         self.criterion = torch.nn.CrossEntropyLoss()
 
-        print(' > Initialised Angular Prototypical loss')
+        print(" > Initialised Angular Prototypical loss")
 
     def forward(self, x):
         """
@@ -152,7 +146,10 @@ class AngleProtoLoss(nn.Module):
         out_positive = x[:, 0, :]
         num_speakers = out_anchor.size()[0]
 
-        cos_sim_matrix = F.cosine_similarity(out_positive.unsqueeze(-1).expand(-1, -1, num_speakers), out_anchor.unsqueeze(-1).expand(-1, -1, num_speakers).transpose(0, 2))
+        cos_sim_matrix = F.cosine_similarity(
+            out_positive.unsqueeze(-1).expand(-1, -1, num_speakers),
+            out_anchor.unsqueeze(-1).expand(-1, -1, num_speakers).transpose(0, 2),
+        )
         torch.clamp(self.w, 1e-6)
         cos_sim_matrix = cos_sim_matrix * self.w + self.b
         label = torch.arange(num_speakers).to(cos_sim_matrix.device)

TTS/speaker_encoder/model.py

@@ -16,19 +16,19 @@ class LSTMWithProjection(nn.Module):
         o, (_, _) = self.lstm(x)
         return self.linear(o)
 
+
 class LSTMWithoutProjection(nn.Module):
     def __init__(self, input_dim, lstm_dim, proj_dim, num_lstm_layers):
         super().__init__()
-        self.lstm = nn.LSTM(input_size=input_dim,
-                            hidden_size=lstm_dim,
-                            num_layers=num_lstm_layers,
-                            batch_first=True)
+        self.lstm = nn.LSTM(input_size=input_dim, hidden_size=lstm_dim, num_layers=num_lstm_layers, batch_first=True)
         self.linear = nn.Linear(lstm_dim, proj_dim, bias=True)
         self.relu = nn.ReLU()
+
     def forward(self, x):
         _, (hidden, _) = self.lstm(x)
         return self.relu(self.linear(hidden[-1]))
 
+
 class SpeakerEncoder(nn.Module):
     def __init__(self, input_dim, proj_dim=256, lstm_dim=768, num_lstm_layers=3, use_lstm_with_projection=True):
         super().__init__()
@@ -106,7 +106,5 @@ class SpeakerEncoder(nn.Module):
             if embed is None:
                 embed = self.inference(frames)
             else:
-                embed[cur_iter <= num_iters, :] += self.inference(
-                    frames[cur_iter <= num_iters, :, :]
-                )
+                embed[cur_iter <= num_iters, :] += self.inference(frames[cur_iter <= num_iters, :, :])
         return embed / num_iters

TTS/speaker_encoder/utils/generic_utils.py

@@ -9,108 +9,114 @@ from TTS.utils.generic_utils import check_argument
 
 def to_camel(text):
     text = text.capitalize()
-    return re.sub(r'(?!^)_([a-zA-Z])', lambda m: m.group(1).upper(), text)
+    return re.sub(r"(?!^)_([a-zA-Z])", lambda m: m.group(1).upper(), text)
 
 
 def setup_model(c):
-    model = SpeakerEncoder(c.model['input_dim'], c.model['proj_dim'],
-                           c.model['lstm_dim'], c.model['num_lstm_layers'])
+    model = SpeakerEncoder(c.model["input_dim"], c.model["proj_dim"], c.model["lstm_dim"], c.model["num_lstm_layers"])
     return model
 
 
-def save_checkpoint(model, optimizer, model_loss, out_path,
-                    current_step, epoch):
-    checkpoint_path = 'checkpoint_{}.pth.tar'.format(current_step)
+def save_checkpoint(model, optimizer, model_loss, out_path, current_step, epoch):
+    checkpoint_path = "checkpoint_{}.pth.tar".format(current_step)
     checkpoint_path = os.path.join(out_path, checkpoint_path)
     print(" | | > Checkpoint saving : {}".format(checkpoint_path))
 
     new_state_dict = model.state_dict()
     state = {
-        'model': new_state_dict,
-        'optimizer': optimizer.state_dict() if optimizer is not None else None,
-        'step': current_step,
-        'epoch': epoch,
-        'loss': model_loss,
-        'date': datetime.date.today().strftime("%B %d, %Y"),
+        "model": new_state_dict,
+        "optimizer": optimizer.state_dict() if optimizer is not None else None,
+        "step": current_step,
+        "epoch": epoch,
+        "loss": model_loss,
+        "date": datetime.date.today().strftime("%B %d, %Y"),
     }
     torch.save(state, checkpoint_path)
 
 
-def save_best_model(model, optimizer, model_loss, best_loss, out_path,
-                    current_step):
+def save_best_model(model, optimizer, model_loss, best_loss, out_path, current_step):
     if model_loss < best_loss:
         new_state_dict = model.state_dict()
         state = {
-            'model': new_state_dict,
-            'optimizer': optimizer.state_dict(),
-            'step': current_step,
-            'loss': model_loss,
-            'date': datetime.date.today().strftime("%B %d, %Y"),
+            "model": new_state_dict,
+            "optimizer": optimizer.state_dict(),
+            "step": current_step,
+            "loss": model_loss,
+            "date": datetime.date.today().strftime("%B %d, %Y"),
         }
         best_loss = model_loss
-        bestmodel_path = 'best_model.pth.tar'
+        bestmodel_path = "best_model.pth.tar"
         bestmodel_path = os.path.join(out_path, bestmodel_path)
-        print("\n > BEST MODEL ({0:.5f}) : {1:}".format(
-            model_loss, bestmodel_path))
+        print("\n > BEST MODEL ({0:.5f}) : {1:}".format(model_loss, bestmodel_path))
         torch.save(state, bestmodel_path)
     return best_loss
 
 
 def check_config_speaker_encoder(c):
     """Check the config.json file of the speaker encoder"""
-    check_argument('run_name', c, restricted=True, val_type=str)
-    check_argument('run_description', c, val_type=str)
+    check_argument("run_name", c, restricted=True, val_type=str)
+    check_argument("run_description", c, val_type=str)
 
     # audio processing parameters
-    check_argument('audio', c, restricted=True, val_type=dict)
-    check_argument('num_mels', c['audio'], restricted=True, val_type=int, min_val=10, max_val=2056)
-    check_argument('fft_size', c['audio'], restricted=True, val_type=int, min_val=128, max_val=4058)
-    check_argument('sample_rate', c['audio'], restricted=True, val_type=int, min_val=512, max_val=100000)
-    check_argument('frame_length_ms', c['audio'], restricted=True, val_type=float, min_val=10, max_val=1000, alternative='win_length')
-    check_argument('frame_shift_ms', c['audio'], restricted=True, val_type=float, min_val=1, max_val=1000, alternative='hop_length')
-    check_argument('preemphasis', c['audio'], restricted=True, val_type=float, min_val=0, max_val=1)
-    check_argument('min_level_db', c['audio'], restricted=True, val_type=int, min_val=-1000, max_val=10)
-    check_argument('ref_level_db', c['audio'], restricted=True, val_type=int, min_val=0, max_val=1000)
-    check_argument('power', c['audio'], restricted=True, val_type=float, min_val=1, max_val=5)
-    check_argument('griffin_lim_iters', c['audio'], restricted=True, val_type=int, min_val=10, max_val=1000)
+    check_argument("audio", c, restricted=True, val_type=dict)
+    check_argument("num_mels", c["audio"], restricted=True, val_type=int, min_val=10, max_val=2056)
+    check_argument("fft_size", c["audio"], restricted=True, val_type=int, min_val=128, max_val=4058)
+    check_argument("sample_rate", c["audio"], restricted=True, val_type=int, min_val=512, max_val=100000)
+    check_argument(
+        "frame_length_ms",
+        c["audio"],
+        restricted=True,
+        val_type=float,
+        min_val=10,
+        max_val=1000,
+        alternative="win_length",
+    )
+    check_argument(
+        "frame_shift_ms", c["audio"], restricted=True, val_type=float, min_val=1, max_val=1000, alternative="hop_length"
+    )
+    check_argument("preemphasis", c["audio"], restricted=True, val_type=float, min_val=0, max_val=1)
+    check_argument("min_level_db", c["audio"], restricted=True, val_type=int, min_val=-1000, max_val=10)
+    check_argument("ref_level_db", c["audio"], restricted=True, val_type=int, min_val=0, max_val=1000)
+    check_argument("power", c["audio"], restricted=True, val_type=float, min_val=1, max_val=5)
+    check_argument("griffin_lim_iters", c["audio"], restricted=True, val_type=int, min_val=10, max_val=1000)
 
     # training parameters
-    check_argument('loss', c, enum_list=['ge2e', 'angleproto'], restricted=True, val_type=str)
-    check_argument('grad_clip', c, restricted=True, val_type=float)
-    check_argument('epochs', c, restricted=True, val_type=int, min_val=1)
-    check_argument('lr', c, restricted=True, val_type=float, min_val=0)
-    check_argument('lr_decay', c, restricted=True, val_type=bool)
-    check_argument('warmup_steps', c, restricted=True, val_type=int, min_val=0)
-    check_argument('tb_model_param_stats', c, restricted=True, val_type=bool)
-    check_argument('num_speakers_in_batch', c, restricted=True, val_type=int)
-    check_argument('num_loader_workers', c, restricted=True, val_type=int)
-    check_argument('wd', c, restricted=True, val_type=float, min_val=0.0, max_val=1.0)
+    check_argument("loss", c, enum_list=["ge2e", "angleproto"], restricted=True, val_type=str)
+    check_argument("grad_clip", c, restricted=True, val_type=float)
+    check_argument("epochs", c, restricted=True, val_type=int, min_val=1)
+    check_argument("lr", c, restricted=True, val_type=float, min_val=0)
+    check_argument("lr_decay", c, restricted=True, val_type=bool)
+    check_argument("warmup_steps", c, restricted=True, val_type=int, min_val=0)
+    check_argument("tb_model_param_stats", c, restricted=True, val_type=bool)
+    check_argument("num_speakers_in_batch", c, restricted=True, val_type=int)
+    check_argument("num_loader_workers", c, restricted=True, val_type=int)
+    check_argument("wd", c, restricted=True, val_type=float, min_val=0.0, max_val=1.0)
 
     # checkpoint and output parameters
-    check_argument('steps_plot_stats', c, restricted=True, val_type=int)
-    check_argument('checkpoint', c, restricted=True, val_type=bool)
-    check_argument('save_step', c, restricted=True, val_type=int)
-    check_argument('print_step', c, restricted=True, val_type=int)
-    check_argument('output_path', c, restricted=True, val_type=str)
+    check_argument("steps_plot_stats", c, restricted=True, val_type=int)
+    check_argument("checkpoint", c, restricted=True, val_type=bool)
+    check_argument("save_step", c, restricted=True, val_type=int)
+    check_argument("print_step", c, restricted=True, val_type=int)
+    check_argument("output_path", c, restricted=True, val_type=str)
 
     # model parameters
-    check_argument('model', c, restricted=True, val_type=dict)
-    check_argument('input_dim', c['model'], restricted=True, val_type=int)
-    check_argument('proj_dim', c['model'], restricted=True, val_type=int)
-    check_argument('lstm_dim', c['model'], restricted=True, val_type=int)
-    check_argument('num_lstm_layers', c['model'], restricted=True, val_type=int)
-    check_argument('use_lstm_with_projection', c['model'], restricted=True, val_type=bool)
+    check_argument("model", c, restricted=True, val_type=dict)
+    check_argument("input_dim", c["model"], restricted=True, val_type=int)
+    check_argument("proj_dim", c["model"], restricted=True, val_type=int)
+    check_argument("lstm_dim", c["model"], restricted=True, val_type=int)
+    check_argument("num_lstm_layers", c["model"], restricted=True, val_type=int)
+    check_argument("use_lstm_with_projection", c["model"], restricted=True, val_type=bool)
 
     # in-memory storage parameters
-    check_argument('storage', c, restricted=True, val_type=dict)
-    check_argument('sample_from_storage_p', c['storage'], restricted=True, val_type=float, min_val=0.0, max_val=1.0)
-    check_argument('storage_size', c['storage'], restricted=True, val_type=int, min_val=1, max_val=100)
-    check_argument('additive_noise', c['storage'], restricted=True, val_type=float, min_val=0.0, max_val=1.0)
+    check_argument("storage", c, restricted=True, val_type=dict)
+    check_argument("sample_from_storage_p", c["storage"], restricted=True, val_type=float, min_val=0.0, max_val=1.0)
+    check_argument("storage_size", c["storage"], restricted=True, val_type=int, min_val=1, max_val=100)
+    check_argument("additive_noise", c["storage"], restricted=True, val_type=float, min_val=0.0, max_val=1.0)
 
     # datasets - checking only the first entry
-    check_argument('datasets', c, restricted=True, val_type=list)
-    for dataset_entry in c['datasets']:
-        check_argument('name', dataset_entry, restricted=True, val_type=str)
-        check_argument('path', dataset_entry, restricted=True, val_type=str)
-        check_argument('meta_file_train', dataset_entry, restricted=True, val_type=[str, list])
-        check_argument('meta_file_val', dataset_entry, restricted=True, val_type=str)
+    check_argument("datasets", c, restricted=True, val_type=list)
+    for dataset_entry in c["datasets"]:
+        check_argument("name", dataset_entry, restricted=True, val_type=str)
+        check_argument("path", dataset_entry, restricted=True, val_type=str)
+        check_argument("meta_file_train", dataset_entry, restricted=True, val_type=[str, list])
+        check_argument("meta_file_val", dataset_entry, restricted=True, val_type=str)

TTS/speaker_encoder/utils/prepare_voxceleb.py

@@ -17,7 +17,7 @@
 # Only support eager mode and TF>=2.0.0
 # pylint: disable=no-member, invalid-name, relative-beyond-top-level
 # pylint: disable=too-many-locals, too-many-statements, too-many-arguments, too-many-instance-attributes
-''' voxceleb 1 & 2 '''
+""" voxceleb 1 & 2 """
 
 import os
 import sys
@@ -32,40 +32,38 @@ import soundfile as sf
 gfile = tf.compat.v1.gfile
 
 SUBSETS = {
-    "vox1_dev_wav":
-        ["http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partaa",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partab",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partac",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partad"],
-    "vox1_test_wav":
-        ["http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_test_wav.zip"],
-    "vox2_dev_aac":
-        ["http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partaa",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partab",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partac",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partad",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partae",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partaf",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partag",
-         "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partah"],
-    "vox2_test_aac":
-        ["http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_test_aac.zip"]
+    "vox1_dev_wav": [
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partaa",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partab",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partac",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partad",
+    ],
+    "vox1_test_wav": ["http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_test_wav.zip"],
+    "vox2_dev_aac": [
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partaa",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partab",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partac",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partad",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partae",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partaf",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partag",
+        "http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_dev_aac_partah",
+    ],
+    "vox2_test_aac": ["http://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox2_test_aac.zip"],
 }
 
 MD5SUM = {
     "vox1_dev_wav": "ae63e55b951748cc486645f532ba230b",
     "vox2_dev_aac": "bbc063c46078a602ca71605645c2a402",
     "vox1_test_wav": "185fdc63c3c739954633d50379a3d102",
-    "vox2_test_aac": "0d2b3ea430a821c33263b5ea37ede312"
+    "vox2_test_aac": "0d2b3ea430a821c33263b5ea37ede312",
 }
 
-USER = {
-    "user": "",
-    "password": ""
-}
+USER = {"user": "", "password": ""}
 
 speaker_id_dict = {}
 
+
 def download_and_extract(directory, subset, urls):
     """Download and extract the given split of dataset.
 
@@ -83,31 +81,30 @@ def download_and_extract(directory, subset, urls):
             if os.path.exists(zip_filepath):
                 continue
             logging.info("Downloading %s to %s" % (url, zip_filepath))
-            subprocess.call('wget %s --user %s --password %s -O %s' %
-                            (url, USER["user"], USER["password"], zip_filepath), shell=True)
+            subprocess.call(
+                "wget %s --user %s --password %s -O %s" % (url, USER["user"], USER["password"], zip_filepath),
+                shell=True,
+            )
 
             statinfo = os.stat(zip_filepath)
-            logging.info(
-                "Successfully downloaded %s, size(bytes): %d" % (url, statinfo.st_size)
-            )
+            logging.info("Successfully downloaded %s, size(bytes): %d" % (url, statinfo.st_size))
 
         # concatenate all parts into zip files
         if ".zip" not in zip_filepath:
             zip_filepath = "_".join(zip_filepath.split("_")[:-1])
-            subprocess.call('cat %s* > %s.zip' %
-                            (zip_filepath, zip_filepath), shell=True)
+            subprocess.call("cat %s* > %s.zip" % (zip_filepath, zip_filepath), shell=True)
             zip_filepath += ".zip"
         extract_path = zip_filepath.strip(".zip")
 
         # check zip file md5sum
-        md5 = hashlib.md5(open(zip_filepath, 'rb').read()).hexdigest()
+        md5 = hashlib.md5(open(zip_filepath, "rb").read()).hexdigest()
         if md5 != MD5SUM[subset]:
             raise ValueError("md5sum of %s mismatch" % zip_filepath)
 
         with zipfile.ZipFile(zip_filepath, "r") as zfile:
             zfile.extractall(directory)
             extract_path_ori = os.path.join(directory, zfile.infolist()[0].filename)
-            subprocess.call('mv %s %s' % (extract_path_ori, extract_path), shell=True)
+            subprocess.call("mv %s %s" % (extract_path_ori, extract_path), shell=True)
     finally:
         # gfile.Remove(zip_filepath)
         pass
@@ -148,8 +145,7 @@ def decode_aac_with_ffmpeg(aac_file, wav_file):
     return True
 
 
-def convert_audio_and_make_label(input_dir, subset,
-                                 output_dir, output_file):
+def convert_audio_and_make_label(input_dir, subset, output_dir, output_file):
     """Optionally convert AAC to WAV and make speaker labels.
     Args:
         input_dir: the directory which holds the input dataset.
@@ -167,7 +163,7 @@ def convert_audio_and_make_label(input_dir, subset,
         for filename in filenames:
             name, ext = os.path.splitext(filename)
             if ext.lower() == ".wav":
-                _, ext2 = (os.path.splitext(name))
+                _, ext2 = os.path.splitext(name)
                 if ext2:
                     continue
                 wav_file = os.path.join(root, filename)
@@ -186,15 +182,12 @@ def convert_audio_and_make_label(input_dir, subset,
                 speaker_id_dict[speaker_name] = num
             # wav_filesize = os.path.getsize(wav_file)
             wav_length = len(sf.read(wav_file)[0])
-            files.append(
-                (os.path.abspath(wav_file), wav_length, speaker_id_dict[speaker_name], speaker_name)
-            )
+            files.append((os.path.abspath(wav_file), wav_length, speaker_id_dict[speaker_name], speaker_name))
 
     # Write to CSV file which contains four columns:
     # "wav_filename", "wav_length_ms", "speaker_id", "speaker_name".
     csv_file_path = os.path.join(output_dir, output_file)
-    df = pandas.DataFrame(
-        data=files, columns=["wav_filename", "wav_length_ms", "speaker_id", "speaker_name"])
+    df = pandas.DataFrame(data=files, columns=["wav_filename", "wav_length_ms", "speaker_id", "speaker_name"])
     df.to_csv(csv_file_path, index=False, sep="\t")
     logging.info("Successfully generated csv file {}".format(csv_file_path))
 
@@ -205,19 +198,14 @@ def processor(directory, subset, force_process):
     if subset not in urls:
         raise ValueError(subset, "is not in voxceleb")
 
-    subset_csv = os.path.join(directory, subset + '.csv')
+    subset_csv = os.path.join(directory, subset + ".csv")
     if not force_process and os.path.exists(subset_csv):
         return subset_csv
 
     logging.info("Downloading and process the voxceleb in %s", directory)
     logging.info("Preparing subset %s", subset)
     download_and_extract(directory, subset, urls[subset])
-    convert_audio_and_make_label(
-        directory,
-        subset,
-        directory,
-        subset + ".csv"
-    )
+    convert_audio_and_make_label(directory, subset, directory, subset + ".csv")
     logging.info("Finished downloading and processing")
     return subset_csv