Esempio n. 1
0
 def __init__(self, in_dim, h_dim, n_res_layers, res_h_dim):
     super(Decoder, self).__init__()
     self.inverse_conv_stack = nn.Sequential(
         nn.ConvTranspose2d(64, 64, 2, 1),
         ResidualStack(64, 64, res_h_dim, n_res_layers),
         nn.ConvTranspose2d(64, 64, 3, 2), nn.ConvTranspose2d(64, 32, 4, 2),
         nn.ConvTranspose2d(32, 3, 8, 4, padding=(1, 2)))
Esempio n. 2
0
    def __init__(self, in_dim, h_dim, n_res_layers, res_h_dim,
                 n_dimension_changes):
        super(Decoder, self).__init__()
        kernel = 4
        stride = 2

        upsample_modules = [
            *(nn.ConvTranspose2d(h_dim // 2,
                                 h_dim // 2,
                                 kernel_size=kernel,
                                 stride=stride,
                                 padding=1), nn.ReLU())
        ] * (n_dimension_changes - 2)

        self.inverse_conv_stack = nn.Sequential(
            nn.ConvTranspose2d(in_dim,
                               h_dim,
                               kernel_size=kernel - 1,
                               stride=stride - 1,
                               padding=1),
            ResidualStack(h_dim, h_dim, res_h_dim, n_res_layers),
            nn.ConvTranspose2d(h_dim,
                               h_dim // 2,
                               kernel_size=kernel,
                               stride=stride,
                               padding=1), nn.ReLU(), *upsample_modules,
            nn.ConvTranspose2d(h_dim // 2,
                               3,
                               kernel_size=kernel,
                               stride=stride,
                               padding=1))
Esempio n. 3
0
    def __init__(self, in_dim, h_dim, n_res_layers, res_h_dim):
        super(Decoder, self).__init__()
        kernel = 4
        stride = 2

        self.inverse_conv_stack = nn.Sequential(
            nn.ConvTranspose1d(h_dim,
                               h_dim,
                               kernel_size=kernel - 1,
                               stride=stride - 1,
                               padding=1),
            ResidualStack(h_dim, h_dim, res_h_dim, n_res_layers),
            nn.ConvTranspose1d(h_dim,
                               h_dim,
                               kernel_size=kernel - 1,
                               stride=stride - 1,
                               padding=1), nn.ReLU(),
            nn.ConvTranspose1d(h_dim,
                               h_dim // 2,
                               kernel_size=kernel,
                               stride=stride,
                               padding=1), nn.ReLU(),
            nn.ConvTranspose1d(h_dim // 2,
                               in_dim,
                               kernel_size=kernel,
                               stride=stride,
                               padding=1))
Esempio n. 4
0
    def __init__(self, in_dim, h_dim, res_h_dim, n_res_layers):
        super(Encoder, self).__init__()

        self.conv_stack = nn.Sequential(
            nn.Conv2d(in_dim, 32, 8, 4), nn.ReLU(), nn.Conv2d(32, 32, 4, 2),
            nn.ReLU(), nn.Conv2d(32, 64, 3, 2),
            ResidualStack(64, 64, res_h_dim, n_res_layers))
Esempio n. 5
0
    def __init__(self, channels, h_dim, n_res_layers, res_h_dim):
        super(Encoder, self).__init__()
        kernel = 4
        stride = 2
        self.conv_stack = nn.Sequential(
            nn.Conv2d(channels, h_dim // 2, kernel_size=kernel,
                      stride=stride, padding=1),
            nn.ReLU(),
            nn.Conv2d(h_dim // 2, h_dim, kernel_size=kernel,
                      stride=stride, padding=1),
            nn.ReLU(),
            nn.Conv2d(h_dim, h_dim, kernel_size=kernel-1,
                      stride=stride-1, padding=1),
            ResidualStack(
                h_dim, h_dim, res_h_dim, n_res_layers)

        )