Missing Generator Under Models and names.pkl

[ajitkumar15]

Generator module is missing
if possible could you please shre the dataset and folder sctucture as names.pkl file is missing.

Can you please help

[intexcor]

Source Generated with Decompyle++

File: decoder.cpython-36.pyc (Python 3.6)

import torch.nn as nn
from torch.nn.utils import spectral_norm
from modules import Conv1d

def Decoder():
'''Decoder'''

def __init__(self = None, in_channels = None, z_channels = None):
    super(Decoder, self).__init__()
    self.in_channels = in_channels
    self.z_channels = z_channels
    self.preprocess = Conv1d(in_channels, 768, 3, **('kernel_size',))
    self.gblocks = nn.ModuleList([
        GBlock(768, 768, z_channels, 1),
        GBlock(768, 768, z_channels, 1),
        GBlock(768, 384, z_channels, 2),
        GBlock(384, 384, z_channels, 2),
        GBlock(384, 384, z_channels, 2),
        GBlock(384, 192, z_channels, 3),
        GBlock(192, 96, z_channels, 5)])
    self.postprocess = nn.Sequential(Conv1d(96, 1, 3, **('kernel_size',)), nn.Tanh())


def forward(self, inputs, z):
    inputs = self.preprocess(inputs)
    outputs = inputs
    for _, layer in enumerate(self.gblocks):
        outputs = layer(outputs, z)
    
    outputs = self.postprocess(outputs)
    return outputs

__classcell__ = None

Decoder = NODE:27(Decoder, 'Decoder', nn.Module)

def GBlock():
'''GBlock'''

def __init__(self = None, in_channels = None, hidden_channels = None, z_channels = None, upsample_factor = None):
    super(GBlock, self).__init__()
    self.in_channels = in_channels
    self.hidden_channels = hidden_channels
    self.z_channels = z_channels
    self.upsample_factor = upsample_factor
    self.condition_batchnorm1 = ConditionalBatchNorm1d(in_channels, z_channels)
    self.first_stack = nn.Sequential(nn.ReLU(False, **('inplace',)), UpsampleNet(in_channels, in_channels, upsample_factor), Conv1d(in_channels, hidden_channels, 3, **('kernel_size',)))
    self.condition_batchnorm2 = ConditionalBatchNorm1d(hidden_channels, z_channels)
    self.second_stack = nn.Sequential(nn.ReLU(False, **('inplace',)), Conv1d(hidden_channels, hidden_channels, 3, 2, **('kernel_size', 'dilation')))
    self.residual1 = nn.Sequential(UpsampleNet(in_channels, in_channels, upsample_factor), Conv1d(in_channels, hidden_channels, 1, **('kernel_size',)))
    self.condition_batchnorm3 = ConditionalBatchNorm1d(hidden_channels, z_channels)
    self.third_stack = nn.Sequential(nn.ReLU(False, **('inplace',)), Conv1d(hidden_channels, hidden_channels, 3, 4, **('kernel_size', 'dilation')))
    self.condition_batchnorm4 = ConditionalBatchNorm1d(hidden_channels, z_channels)
    self.fourth_stack = nn.Sequential(nn.ReLU(False, **('inplace',)), Conv1d(hidden_channels, hidden_channels, 3, 8, **('kernel_size', 'dilation')))


def forward(self, condition, z):
    inputs = condition
    outputs = self.condition_batchnorm1(inputs, z)
    outputs = self.first_stack(outputs)
    outputs = self.condition_batchnorm2(outputs, z)
    outputs = self.second_stack(outputs)
    residual_outputs = self.residual1(inputs) + outputs
    outputs = self.condition_batchnorm3(residual_outputs, z)
    outputs = self.third_stack(outputs)
    outputs = self.condition_batchnorm4(outputs, z)
    outputs = self.fourth_stack(outputs)
    outputs = outputs + residual_outputs
    return outputs

__classcell__ = None

GBlock = NODE:27(GBlock, 'GBlock', nn.Module)

def UpsampleNet():
'''UpsampleNet'''

def __init__(self = None, input_size = None, output_size = None, upsample_factor = None):
    super(UpsampleNet, self).__init__()
    self.input_size = input_size
    self.output_size = output_size
    self.upsample_factor = upsample_factor
    layer = nn.ConvTranspose1d(input_size, output_size, upsample_factor * 2, upsample_factor, upsample_factor // 2, **('padding',))
    nn.init.orthogonal_(layer.weight)
    self.layer = spectral_norm(layer)


def forward(self, inputs):
    outputs = self.layer(inputs)
    outputs = outputs[(:, :, :inputs.size(-1) * self.upsample_factor)]
    return outputs

__classcell__ = None

UpsampleNet = NODE:27(UpsampleNet, 'UpsampleNet', nn.Module)

def ConditionalBatchNorm1d():
'''ConditionalBatchNorm1d'''
doc = 'Conditional Batch Normalization'

def __init__(self = None, num_features = None, z_channels = None):
    super().__init__()
    self.num_features = num_features
    self.z_channels = z_channels
    self.batch_nrom = nn.BatchNorm1d(num_features, False, **('affine',))
    self.layer = spectral_norm(nn.Linear(z_channels, num_features * 2))
    self.layer.weight.data.normal_(1, 0.02)
    self.layer.bias.data.zero_()


def forward(self, inputs, noise):
    outputs = self.batch_nrom(inputs)
    (gamma, beta) = self.layer(noise).chunk(2, 1)
    gamma = gamma.view(-1, self.num_features, 1)
    beta = beta.view(-1, self.num_features, 1)
    outputs = gamma * outputs + beta
    return outputs

__classcell__ = None

ConditionalBatchNorm1d = NODE:27(ConditionalBatchNorm1d, 'ConditionalBatchNorm1d', nn.Module)

декодировал из pyc файла