Update app.py

app.py

@@ -409,45 +409,45 @@ class TrinerModelVITS:
         self.init_wandb()
         # self.training_args=load_training_args(self.path_training_args)
         # training_args= self.training_args
-        scaler = GradScaler(enabled=True)
-        for disc in self.model.discriminator.discriminators:
-            disc.apply_weight_norm()
-        self.model.decoder.apply_weight_norm()
-        # torch.nn.utils.weight_norm(self.decoder.conv_pre)
-        # torch.nn.utils.weight_norm(self.decoder.conv_post)
-        for flow in self.model.flow.flows:
-            torch.nn.utils.weight_norm(flow.conv_pre)
-            torch.nn.utils.weight_norm(flow.conv_post)
+        # scaler = GradScaler(enabled=True)
+        # for disc in self.model.discriminator.discriminators:
+        #     disc.apply_weight_norm()
+        # self.model.decoder.apply_weight_norm()
+        # # torch.nn.utils.weight_norm(self.decoder.conv_pre)
+        # # torch.nn.utils.weight_norm(self.decoder.conv_post)
+        # for flow in self.model.flow.flows:
+        #     torch.nn.utils.weight_norm(flow.conv_pre)
+        #     torch.nn.utils.weight_norm(flow.conv_post)
 
-        discriminator = self.model.discriminator
-        self.model.discriminator = None
+        # discriminator = self.model.discriminator
+        # self.model.discriminator = None
 
-        optimizer = torch.optim.AdamW(
-            self.model.parameters(),
-            2e-4,
-            betas=[0.8, 0.99],
-           # eps=training_args.adam_epsilon,
-        )
+        # optimizer = torch.optim.AdamW(
+        #     self.model.parameters(),
+        #     2e-4,
+        #     betas=[0.8, 0.99],
+        #    # eps=training_args.adam_epsilon,
+        # )
 
-        # Hack to be able to train on multiple device
-        disc_optimizer = torch.optim.AdamW(
-            discriminator.parameters(),
-             2e-4,
-            betas=[0.8, 0.99],
-          #  eps=training_args.adam_epsilon,
-        )
-        lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(
-            optimizer,gamma=0.999875, last_epoch=-1
-        )
-        disc_lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(
-            disc_optimizer, gamma=0.999875,last_epoch=-1
-        )
-        self.models=(self.model,discriminator)
-        self.optimizers=(optimizer,disc_optimizer,scaler)
-        self.lr_schedulers=(lr_scheduler,disc_lr_scheduler)
-        self.tools=load_tools()
-        self.stute_mode=True
-        print(self.lr_schedulers)
+        # # Hack to be able to train on multiple device
+        # disc_optimizer = torch.optim.AdamW(
+        #     discriminator.parameters(),
+        #      2e-4,
+        #     betas=[0.8, 0.99],
+        #   #  eps=training_args.adam_epsilon,
+        # )
+        # lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(
+        #     optimizer,gamma=0.999875, last_epoch=-1
+        # )
+        # disc_lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(
+        #     disc_optimizer, gamma=0.999875,last_epoch=-1
+        # )
+        # self.models=(self.model,discriminator)
+        # self.optimizers=(optimizer,disc_optimizer,scaler)
+        # self.lr_schedulers=(lr_scheduler,disc_lr_scheduler)
+        # self.tools=load_tools()
+        # self.stute_mode=True
+        # print(self.lr_schedulers)
         
        
         
@@ -502,49 +502,49 @@ class TrinerModelVITS:
         training_args.num_train_epochs=4
         training_args.eval_steps=1000
 
-        # set_seed(training_args.seed)
-        # scaler = GradScaler(enabled=training_args.fp16)
+        set_seed(training_args.seed)
+        scaler = GradScaler(enabled=training_args.fp16)
         
 
-        # # Initialize optimizer, lr_scheduler
-        # for disc in self.model.discriminator.discriminators:
-        #     disc.apply_weight_norm()
-        # self.model.decoder.apply_weight_norm()
-        # # torch.nn.utils.weight_norm(self.decoder.conv_pre)
-        # # torch.nn.utils.weight_norm(self.decoder.conv_post)
-        # for flow in self.model.flow.flows:
-        #     torch.nn.utils.weight_norm(flow.conv_pre)
-        #     torch.nn.utils.weight_norm(flow.conv_post)
+        # Initialize optimizer, lr_scheduler
+        for disc in self.model.discriminator.discriminators:
+            disc.apply_weight_norm()
+        self.model.decoder.apply_weight_norm()
+        # torch.nn.utils.weight_norm(self.decoder.conv_pre)
+        # torch.nn.utils.weight_norm(self.decoder.conv_post)
+        for flow in self.model.flow.flows:
+            torch.nn.utils.weight_norm(flow.conv_pre)
+            torch.nn.utils.weight_norm(flow.conv_post)
 
-        # discriminator = self.model.discriminator
-        # self.model.discriminator = None
+        discriminator = self.model.discriminator
+        self.model.discriminator = None
 
-        # optimizer = torch.optim.AdamW(
-        #     self.model.parameters(),
-        #     training_args.learning_rate,
-        #     betas=[training_args.adam_beta1, training_args.adam_beta2],
-        #     eps=training_args.adam_epsilon,
-        # )
+        optimizer = torch.optim.AdamW(
+            self.model.parameters(),
+            training_args.learning_rate,
+            betas=[training_args.adam_beta1, training_args.adam_beta2],
+            eps=training_args.adam_epsilon,
+        )
 
-        # # Hack to be able to train on multiple device
-        # disc_optimizer = torch.optim.AdamW(
-        #     discriminator.parameters(),
-        #     training_args.d_learning_rate,
-        #     betas=[training_args.d_adam_beta1, training_args.d_adam_beta2],
-        #     eps=training_args.adam_epsilon,
-        # )
-        # lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(
-        #     optimizer, gamma=training_args.lr_decay, last_epoch=-1
-        # )
-        # disc_lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(
-        #     disc_optimizer, gamma=training_args.lr_decay, last_epoch=-1
-        # )
-        # self.models=(self.model,discriminator)
-        # self.optimizers=(optimizer,disc_optimizer,scaler)
-        # self.lr_schedulers=(lr_scheduler,disc_lr_scheduler)
-        # self.tools=load_tools()
-        # self.stute_mode=True
-        # print(self.lr_schedulers)
+        # Hack to be able to train on multiple device
+        disc_optimizer = torch.optim.AdamW(
+            discriminator.parameters(),
+            training_args.d_learning_rate,
+            betas=[training_args.d_adam_beta1, training_args.d_adam_beta2],
+            eps=training_args.adam_epsilon,
+        )
+        lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(
+            optimizer, gamma=training_args.lr_decay, last_epoch=-1
+        )
+        disc_lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(
+            disc_optimizer, gamma=training_args.lr_decay, last_epoch=-1
+        )
+        self.models=(self.model,discriminator)
+        self.optimizers=(optimizer,disc_optimizer,scaler)
+        self.lr_schedulers=(lr_scheduler,disc_lr_scheduler)
+        self.tools=load_tools()
+        self.stute_mode=True
+        print(self.lr_schedulers)
       
 
     
@@ -610,7 +610,7 @@ train_dataset_dirs=[
           # ('/content/drive/MyDrive/vitsM/DATA/wafa-db',4),
           # ('/content/drive/MyDrive/vitsM/DATA/DB-ABThag-Bitch:5-Count-37',4),
          # ('/content/drive/MyDrive/vitsM/DB-300-k',6),
-         ('ABThag-db',0),
+         ('databatchs',0),
          #('/content/drive/MyDrive/dataset_ljBatchs',0),