Download model.py from Kremon96/NGAN: direct link, hf CLI and curl.
- Browser
- Download file 5.23 kB
-
https://huggingface.co/Kremon96/NGAN/resolve/main/model.py
- Command line
-
hf download hf://Kremon96/NGAN/model.py
-
curl -L -o model.py https://huggingface.co/Kremon96/NGAN/resolve/main/model.py
5.23 kB
| import os | |
| os.environ.setdefault("CUDA_VISIBLE_DEVICES", "2") | |
| from itertools import chain | |
| import torch | |
| torch.manual_seed(42) | |
| from encodec.msstftd import MultiScaleSTFTDiscriminator | |
| from layers import ReconstructionLoss, SuperResolver | |
| from data import make_dataloader | |
| try: | |
| import pytorch_lightning as pl | |
| except ImportError: | |
| class pl: | |
| class LightningModule: | |
| pass | |
| class Callback: | |
| pass | |
| l1Loss = torch.nn.L1Loss(reduction='mean') | |
| l2Loss = torch.nn.MSELoss(reduction='mean') | |
| class NGAN(pl.LightningModule): | |
| def __init__( | |
| self, | |
| n_channels: int = 8, | |
| padding: str = 'check', | |
| batch_size: int = 32, | |
| target_sample_rate: int = 48000, | |
| segment_length: int = 24000, | |
| train_data: str = None, | |
| lr: float = 1e-4, | |
| b1: float = 0.5, | |
| b2: float = 0.9 | |
| ) -> None: | |
| # Method from https://arxiv.org/pdf/2009.02095.pdf | |
| # SEANet uses Adam with lr=1e-4, beta1=0.5, beta2=0.9 | |
| # batch_size=16 | |
| super().__init__() | |
| self.save_hyperparameters() | |
| self.automatic_optimization = False | |
| self.superResolver = SuperResolver(n_channels, padding) | |
| self.rec_loss = ReconstructionLoss() | |
| self.msstft_discriminator = MultiScaleSTFTDiscriminator(filters=32, | |
| hop_lengths=[256, 512, 128], | |
| win_lengths=[1024, 2048, 512], | |
| n_ffts=[1024, 2048, 512]) | |
| def configure_optimizers(self): | |
| lr = self.hparams.lr | |
| b1 = self.hparams.b1 | |
| b2 = self.hparams.b2 | |
| optimizer_g = torch.optim.Adam( | |
| chain( | |
| self.superResolver.parameters() | |
| ), | |
| lr=lr, betas=(b1, b2)) | |
| optimizer_d = torch.optim.Adam( | |
| chain( | |
| self.msstft_discriminator.parameters() | |
| ), | |
| lr=lr, betas=(b1, b2)) | |
| return [optimizer_g, optimizer_d], [] | |
| def forward(self, input): | |
| x = self.superResolver(input) | |
| return x | |
| def training_step(self, batch, batch_idx): | |
| optimizer_g, optimizer_d = self.optimizers() | |
| # train generator | |
| self.toggle_optimizer(optimizer_g) | |
| output = self.forward(batch) | |
| # output: [batch, channel, sequence] | |
| #multi-scale stft generator loss | |
| relu = torch.nn.ReLU() | |
| l_g = 0 | |
| l_feat = 0 | |
| input_orig = batch[0][:, None, :] | |
| logits_real, fmap_real = self.msstft_discriminator(input_orig) | |
| logits_fake, fmap_fake = self.msstft_discriminator(output) | |
| for tt1 in range(len(fmap_real)): | |
| l_g = l_g + torch.mean(relu(1 - logits_fake[tt1])) / len(logits_fake) | |
| for tt2 in range(len(fmap_real[tt1])): | |
| l_feat = l_feat + l1Loss(fmap_real[tt1][tt2], fmap_fake[tt1][tt2]) / torch.mean(torch.abs(fmap_real[tt1][tt2])) | |
| KL_scale = len(fmap_real)*len(fmap_real[0]) | |
| K_scale = len(fmap_real) | |
| #time domain loss, output_wav is the output of the generator | |
| l_t = l1Loss(input_orig, output) | |
| g_rec_loss = self.rec_loss(output[:, 0, :], input_orig[:, 0, :]) | |
| g_loss = 3*l_g/K_scale + 3*l_feat/KL_scale + (l_t / 10) + g_rec_loss | |
| self.log("g_loss", g_loss, prog_bar=True) | |
| self.manual_backward(g_loss) | |
| optimizer_g.step() | |
| optimizer_g.zero_grad() | |
| self.untoggle_optimizer(optimizer_g) | |
| # train discriminator | |
| relu = torch.nn.ReLU() | |
| logits_real, _ = self.msstft_discriminator(input_orig) | |
| logits_fake, _ = self.msstft_discriminator(output.detach()) | |
| lossd = 0 | |
| for tt1 in range(len(logits_real)): | |
| lossd = lossd + torch.mean(relu(1-logits_real[tt1])) + torch.mean(relu(1+logits_fake[tt1])) | |
| d_loss = lossd / len(logits_real) | |
| self.log("d_loss", d_loss, prog_bar=True) | |
| self.manual_backward(d_loss) | |
| optimizer_d.step() | |
| optimizer_d.zero_grad() | |
| self.untoggle_optimizer(optimizer_d) | |
| def train_dataloader(self): | |
| return make_dataloader( | |
| root=self.hparams.train_data, | |
| segment_length=self.hparams.segment_length, | |
| target_sample_rate=self.hparams.target_sample_rate, | |
| batch_size=self.hparams.batch_size) | |
| def train(): | |
| model = NGAN( | |
| batch_size = 32, | |
| padding = 'same') | |
| #During training can load weights from checkpoint | |
| ## checkpoint = torch.load('./models/generator_discrim.ckpt')['state_dict'] | |
| #Can save weights for just the geneartor for inference at end of training | |
| ## model.load_state_dict(checkpoint) | |
| ## torch.save(model.superResolver.state_dict(), 'generators/n1x.ckpt') | |
| trainer = pl.Trainer( | |
| max_epochs=200, | |
| precision='16-mixed', | |
| logger=pl.loggers.CSVLogger("."), | |
| # set file name and directory name for checkpoints | |
| callbacks=[ | |
| pl.callbacks.ModelCheckpoint(save_last=True, every_n_train_steps=50000, filename='generator_discrim', dirpath='./models') | |
| ], | |
| ) | |
| trainer.fit( | |
| model, | |
| ) | |
| return model | |
| if __name__ == "__main__": | |
| train() | |