Delete models.py

models.py

@@ -1,88 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class ResBlock1(nn.Module):
-    def __init__(self, channels, kernel_size, dilation):
-        super(ResBlock1, self).__init__()
-        self.convs1 = nn.ModuleList([
-            nn.utils.weight_norm(nn.Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                                           padding=self.get_padding(kernel_size, dilation[0]))),
-            nn.utils.weight_norm(nn.Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                                           padding=self.get_padding(kernel_size, dilation[1]))),
-            nn.utils.weight_norm(nn.Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
-                                           padding=self.get_padding(kernel_size, dilation[2])))
-        ])
-        self.convs2 = nn.ModuleList([
-            nn.utils.weight_norm(nn.Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                                           padding=self.get_padding(kernel_size, 1))),
-            nn.utils.weight_norm(nn.Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                                           padding=self.get_padding(kernel_size, 1))),
-            nn.utils.weight_norm(nn.Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                                           padding=self.get_padding(kernel_size, 1)))
-        ])
-
-    def get_padding(self, kernel_size, dilation):
-        return int((kernel_size * dilation - dilation) / 2)
-
-    def forward(self, x):
-        for c1, c2 in zip(self.convs1, self.convs2):
-            xt = F.leaky_relu(x, 0.1)
-            xt = c1(xt)
-            xt = F.leaky_relu(xt, 0.1)
-            xt = c2(xt)
-            x = xt + x
-        return x
-
-
-class Generator(nn.Module):
-    def __init__(self, config):
-        super(Generator, self).__init__()
-        self.num_kernels = len(config["resblock_kernel_sizes"])
-        self.num_upsamples = len(config["upsample_rates"])
-        self.conv_pre = nn.utils.weight_norm(
-            nn.Conv1d(config["model_in_dim"], config["upsample_initial_channel"], 7, 1, padding=3)
-        )
-
-        resblock = ResBlock1
-        self.ups = nn.ModuleList()
-        self.resblocks = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(config["upsample_rates"], config["upsample_kernel_sizes"])):
-            self.ups.append(
-                nn.utils.weight_norm(
-                    nn.ConvTranspose1d(
-                        config["upsample_initial_channel"] // (2 ** i),
-                        config["upsample_initial_channel"] // (2 ** (i + 1)),
-                        k, u, padding=(k - u) // 2
-                    )
-                )
-            )
-            for j in range(self.num_kernels):
-                self.resblocks.append(
-                    resblock(
-                        config["upsample_initial_channel"] // (2 ** (i + 1)),
-                        config["resblock_kernel_sizes"][j],
-                        config["resblock_dilation_sizes"][j]
-                    )
-                )
-
-        self.conv_post = nn.utils.weight_norm(
-            nn.Conv1d(config["upsample_initial_channel"] // (2 ** self.num_upsamples), 1, 7, 1, padding=3)
-        )
-
-    def forward(self, x):
-        x = self.conv_pre(x)
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, 0.1)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                idx = i * self.num_kernels + j
-                xt = self.resblocks[idx](x)
-                xs = xt if xs is None else xs + xt
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-        return x