def __init__(self, args): super(VAE, self).__init__(args) # encoder: q(z | x) self.q_z_layers = nn.Sequential( GatedDense(np.prod(self.args.input_size), 300), GatedDense(300, 300) ) self.q_z_mean = Linear(300, self.args.z1_size) self.q_z_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6.,max_val=2.)) # decoder: p(x | z) self.p_x_layers = nn.Sequential( GatedDense(self.args.z1_size, 300), GatedDense(300, 300) ) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(300, np.prod(self.args.input_size), activation=nn.Hardtanh(min_val=-4.5,max_val=0)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(Encoder, self).__init__() self.input_size = args.input_size if args.dataset_name == 'freyfaces': h_size = 210 elif args.dataset_name.startswith( 'cifar10' ) or args.dataset_name == 'coil20' or args.dataset_name == 'svhn': h_size = 384 elif args.dataset_name == 'usps': h_size = 96 elif args.dataset_name == 'celeba': h_size = 1536 else: h_size = 294 self.n_z = args.z_size self.main = nn.Sequential(GatedConv2d(self.input_size[0], 32, 7, 1, 3), GatedConv2d(32, 32, 3, 2, 1), GatedConv2d(32, 64, 5, 1, 2), GatedConv2d(64, 64, 3, 2, 1), GatedConv2d(64, 6, 3, 1, 1)) # linear layers self.fc = NonLinear(h_size, self.n_z, activation=None) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m)
def __init__(self, args): super(Decoder, self).__init__() self.input_size = args.input_size self.input_type = args.input_type self.n_z = args.z_size self.fc = nn.Sequential(GatedDense(self.n_z, 300), GatedDense(300, np.prod(self.input_size))) self.main = nn.Sequential(GatedConv2d(self.input_size[0], 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1)) if self.input_type == 'binary': self.p_x_mean = Conv2d(64, 1, 1, 1, 0, activation=nn.Sigmoid()) elif self.input_type == 'gray' or self.input_type == 'continuous': self.p_x_mean = Conv2d(64, self.input_size[0], 1, 1, 0, activation=nn.Sigmoid()) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m)
def __init__(self, args): super().__init__() self.input_size = args.input_size self.n_z = args.z_size self.MI_obj = args.MI_obj if args.dataset_name == 'freyfaces': h_size = 210 elif args.dataset_name == 'cifar10': h_size = 384 else: h_size = 294 self.main_x = nn.Sequential( Conv2d(self.input_size[0], 32, 7, 1, 3, activation = nn.ELU()), Conv2d(32, 32, 3, 2, 1, activation = nn.ELU()), Conv2d(32, 64, 5, 1, 2, activation = nn.ELU()), Conv2d(64, 64, 3, 2, 1, activation = nn.ELU()), Conv2d(64, 6, 3, 1, 1, activation = nn.ELU()) ) self.main_z = NonLinear(self.n_z, h_size, activation=None) self.joint = NonLinear(2 * h_size, 1, activation=None) self.ma_et = None # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m)
def __init__(self, args): super(VAE, self).__init__(args) assert args.input_size[1] == args.input_size[2] # encoder: q(z | x) self.q_z_layers = nn.Sequential( nn.LSTM(args.input_size[1], int(args.h1_size/2), num_layers=1, batch_first=True, bidirectional=True)) self.q_z_mean = Linear(args.h1_size, self.args.z1_size) self.q_z_logvar = NonLinear(args.h1_size, self.args.z1_size, activation=nn.Hardtanh(min_val=-6.,max_val=2.)) # decoder: p(x | z) self.p_x_layers = nn.Sequential( nn.LSTM(args.input_size[1]+args.z1_size, args.h1_size, num_layers=1, batch_first=True)) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(args.h1_size, args.input_size[2], activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': raise Exception('not implemented yet!') self.p_x_mean = NonLinear(args.h1_size, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(args.h1_size, np.prod(self.args.input_size), activation=nn.Hardtanh(min_val=-4.5,max_val=0)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(conv_vae, self).__init__(args) # encoder: q(z | x) d = 32 act = F.relu self.q_z_layers = nn.Sequential( GatedConv2d(self.args.input_size[0], d, 4, 2, 1, activation=act), GatedConv2d(d, 2 * d, 4, 2, 1, activation=act), GatedConv2d(2 * d, 4 * d, 4, 2, 1, activation=act), GatedConv2d(4 * d, 8 * d, 4, 2, 1, activation=act), GatedConv2d(8 * d, self.args.z1_size, 4, 1, 0, activation=None)) self.q_z_mean = Linear(self.args.z1_size, self.args.z1_size) self.q_z_logvar = NonLinear(self.args.z1_size, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder: p(x | z) self.p_x_layers = nn.Sequential( GatedConvTranspose2d(self.args.z1_size, 8 * d, 4, 1, 0, activation=act), GatedConvTranspose2d(8 * d, 4 * d, 4, 2, 1, activation=act), GatedConvTranspose2d(4 * d, 2 * d, 4, 2, 1, activation=act), GatedConvTranspose2d(2 * d, d, 4, 2, 1, activation=act), GatedConvTranspose2d(d, d, 4, 2, 1, activation=None)) if self.args.input_type == 'binary': self.p_x_mean = Conv2d(d, 1, 1, 1, 0, activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = Conv2d(d, self.args.input_size[0], 1, 1, 0, activation=nn.Sigmoid()) self.p_x_logvar = Conv2d(d, self.args.input_size[0], 1, 1, 0, activation=nn.Hardtanh(min_val=-4.5, max_val=0.)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs() elif self.args.prior == 'GMM': self.initialize_GMMparams(Kmog=10, mode='random')
def __init__(self, args): super(VAE, self).__init__(args) # encoder: q(z | x) self.q_z_layers = iRevNet(nBlocks=[18, 18], nStrides=[1, 2], nChannels=[16, 64], nClasses=300, init_ds=2, dropout_rate=0.1, affineBN=True, in_shape=self.args.input_size, mult=4) #self.q_z_layers = nn.DataParallel(self.q_z_layers) self.q_z_mean = Linear(300, self.args.z1_size) self.q_z_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder: p(x | z) self.p_x_layers = [ NonGatedDense(self.args.z1_size, 300, activation=nn.ReLU()) ] for i in range(args.number_hidden): self.p_x_layers.append( NonGatedDense(300, 300, activation=nn.ReLU())) self.p_x_layers = nn.ModuleList(self.p_x_layers) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(300, np.prod(self.args.input_size), activation=nn.Hardtanh(min_val=-4.5, max_val=0)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) # encoder: q(z | x) self.q_z_layers = nn.Sequential( GatedDense(np.prod(self.args.input_size), 300), GatedDense(300, 300)) self.q_z_mean = Linear(300, self.args.z1_size) if args.dataset_name.startswith('gmm'): self.q_z_logvar = NonLinear(300, self.args.z1_size, activation=None) else: self.q_z_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder: p(x | z) self.p_x_layers = nn.Sequential(GatedDense(self.args.z1_size, 300), GatedDense(300, 300)) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': if args.dataset_name.startswith('gmm'): self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=None) self.p_x_logvar = NonLinear(300, np.prod(self.args.input_size), activation=None) else: self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(300, np.prod(self.args.input_size), activation=nn.Hardtanh( min_val=-4.5, max_val=0)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) # encoder: q(z | x) self.q_z_layers = [GatedDense(np.prod(self.args.input_size), 300)] for i in range(args.number_hidden): self.q_z_layers.append(NonGatedDense(300, 300)) self.q_z_layers = nn.ModuleList(self.q_z_layers) self.q_z_mean = Linear(300, self.args.z1_size) self.q_z_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6.,max_val=2.)) # decoder: p(x | z) self.p_x_layers = [GatedDense(self.args.z1_size, 300)] for i in range(args.number_hidden/2): self.p_x_layers.append(NonGatedDense(300, 300)) self.p_x_layers = nn.ModuleList(self.p_x_layers) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(300, np.prod(self.args.input_size), activation=nn.Hardtanh(min_val=-4.5,max_val=0)) # convex combination linear Inverse Autoregressive flow self.encoder_y = [nn.Linear( 300, self.args.number_combination ) for j in range(len(self.q_z_layers))] self.encoder_L = [nn.Linear( 300, (300**2) * self.args.number_combination ) for j in range(len(self.q_z_layers))] self.encoder_y = nn.ModuleList(self.encoder_y) self.encoder_L = nn.ModuleList(self.encoder_L) self.decoder_y = [nn.Linear( 300, self.args.number_combination ) for j in range(len(self.p_x_layers))] self.decoder_L = [nn.Linear( 300, (300**2) * self.args.number_combination ) for j in range(len(self.p_x_layers))] self.decoder_y = nn.ModuleList(self.decoder_y) self.decoder_L = nn.ModuleList(self.decoder_L) self.sigmoid = nn.Sigmoid() self.softmax = nn.Softmax() self.linIAF = linIAF(self.args) self.combination_L = combination_L(self.args) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) # encoder: q(z | x) self.q_z_layers = [ NonGatedDense(np.prod(self.args.input_size), 300, activation=nn.ReLU()) ] for i in range(args.number_hidden): self.q_z_layers.append( NonGatedDense(300, 300, activation=nn.ReLU())) self.q_z_layers = nn.ModuleList(self.q_z_layers) self.q_z_mean = Linear(300, self.args.z1_size) self.q_z_logvar = Linear( 300, self.args.z1_size ) #NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6.,max_val=2.)) # decoder: p(x | z) self.p_x_layers = [ NonGatedDense(self.args.z1_size, 300, activation=nn.ReLU()) ] for i in range(args.number_hidden): self.p_x_layers.append( NonGatedDense(300, 300, activation=nn.ReLU())) self.p_x_layers = nn.ModuleList(self.p_x_layers) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(300, np.prod(self.args.input_size), activation=nn.Hardtanh(min_val=-4.5, max_val=0)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) # encoder: q(z | x) modules = [ nn.Dropout(p=0.5), NonLinear(np.prod(self.args.input_size), self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh()) ] for _ in range(0, self.args.num_layers - 1): modules.append( NonLinear(self.args.hidden_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh())) self.q_z_layers = nn.Sequential(*modules) self.q_z_mean = Linear(self.args.hidden_size, self.args.z1_size) self.q_z_logvar = NonLinear(self.args.hidden_size, self.args.z1_size, activation=nn.Hardtanh(min_val=-12., max_val=4.)) # decoder: p(x | z) modules = [ NonLinear(self.args.z1_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh()) ] for _ in range(0, self.args.num_layers - 1): modules.append( NonLinear(self.args.hidden_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh())) self.p_x_layers = nn.Sequential(*modules) self.p_x_mean = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=None) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m)
def __init__(self, args): super(Decoder, self).__init__() self.input_size = args.input_size self.n_z = args.z_size self.main = nn.Sequential(GatedDense(self.n_z, 300), GatedDense(300, 300)) self.fc = NonLinear(300, np.prod(self.input_size), activation=None) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m)
def __init__(self, args): super(SSVAE, self).__init__(args) assert self.args.prior != 'GMM' assert self.args.prior != 'vampprior' assert not self.args.separate_means # encoder: q(z | x) self.q_z_layers = nn.Sequential( GatedDense(np.prod(self.args.input_size), 300), GatedDense(300, 300)) self.q_z_mean = Linear(300, self.args.z1_size) self.q_z_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder: p(x | z) self.p_x_layers = nn.Sequential(GatedDense(self.args.z1_size, 300), GatedDense(300, 300)) #if self.args.input_type == 'binary': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) #elif self.args.input_type in ['gray', 'continuous', 'color']: # self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) # self.p_x_logvar = NonLinear(300, np.prod(self.args.input_size), activation=nn.Hardtanh(min_val=-4.5,max_val=0)) self.mixingw_c = np.ones(self.args.number_components) #self.semi_supervisor = nn.Sequential(Linear(args.z1_size, args.num_classes), # nn.Softmax()) self.semi_supervisor = nn.Sequential( GatedDense(args.z1_size, args.z1_size), nn.Dropout(0.5), GatedDense(args.z1_size, args.num_classes), nn.Softmax()) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior in ['vampprior', 'vampprior_short']: self.add_pseudoinputs()
def __init__(self, args): super(Encoder_z_prior, self).__init__() self.input_size = args.input_size self.n_z = args.z_size self.main = nn.Sequential(GatedDense(np.prod(self.input_size), 300), GatedDense(300, 300)) #assume Gaussian distribution for p(z_d|x_e) self.p_z_mean = NonLinear(300, self.n_z, activation=None) self.p_z_logvar = NonLinear(300, self.n_z, activation=nn.Hardtanh(min_val=-9., max_val=-3.2)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m)
def __init__(self, args): super(VAE, self).__init__(args) self.args = args # encoder: q(z2 | x) self.q_z2_layers = nn.Sequential( GatedDense(np.prod(self.args.input_size), 300), GatedDense(300, 300) ) self.q_z2_mean = Linear(300, self.args.z2_size) self.q_z2_logvar = NonLinear(300, self.args.z2_size, activation=nn.Hardtanh(min_val=-6.,max_val=2.)) # encoder: q(z1 | x, z2) self.q_z1_layers_x = nn.Sequential( GatedDense(np.prod(self.args.input_size), 300) ) self.q_z1_layers_z2 = nn.Sequential( GatedDense(self.args.z2_size, 300) ) self.q_z1_layers_joint = nn.Sequential( GatedDense(2 * 300, 300) ) self.q_z1_mean = Linear(300, self.args.z1_size) self.q_z1_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6.,max_val=2.)) # decoder: p(z1 | z2) self.p_z1_layers = nn.Sequential( GatedDense(self.args.z2_size, 300), GatedDense(300, 300) ) self.p_z1_mean = Linear(300, self.args.z1_size) self.p_z1_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6.,max_val=2.)) # decoder: p(x | z1, z2) self.p_x_layers_z1 = nn.Sequential( GatedDense(self.args.z1_size, 300) ) self.p_x_layers_z2 = nn.Sequential( GatedDense(self.args.z2_size, 300) ) self.p_x_layers_joint = nn.Sequential( GatedDense(2 * 300, 300) ) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = NonLinear(300, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(300, np.prod(self.args.input_size), activation=nn.Hardtanh(min_val=-4.5,max_val=0)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) if self.args.dataset_name == 'freyfaces': h_size = 210 elif self.args.dataset_name == 'cifar10': h_size = 384 elif self.args.dataset_name == 'celeba': h_size = 6144 else: h_size = 294 # encoder: q(z2 | x) self.q_z2_layers = nn.Sequential( GatedConv2d(self.args.input_size[0], 32, 7, 1, 3), GatedConv2d(32, 32, 3, 2, 1), GatedConv2d(32, 64, 5, 1, 2), GatedConv2d(64, 64, 3, 2, 1), GatedConv2d(64, 6, 3, 1, 1)) # linear layers self.q_z2_mean = NonLinear(h_size, self.args.z2_size, activation=None) self.q_z2_logvar = NonLinear(h_size, self.args.z2_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # encoder: q(z1|x,z2) # PROCESSING x self.q_z1_layers_x = nn.Sequential( GatedConv2d(self.args.input_size[0], 32, 3, 1, 1), GatedConv2d(32, 32, 3, 2, 1), GatedConv2d(32, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 2, 1), GatedConv2d(64, 6, 3, 1, 1)) # PROCESSING Z2 self.q_z1_layers_z2 = nn.Sequential( GatedDense(self.args.z2_size, h_size)) # PROCESSING JOINT self.q_z1_layers_joint = nn.Sequential(GatedDense(2 * h_size, 300)) # linear layers self.q_z1_mean = NonLinear(300, self.args.z1_size, activation=None) self.q_z1_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder p(z1|z2) self.p_z1_layers = nn.Sequential(GatedDense(self.args.z2_size, 300), GatedDense(300, 300)) self.p_z1_mean = NonLinear(300, self.args.z1_size, activation=None) self.p_z1_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder: p(x | z) self.p_x_layers_z1 = nn.Sequential(GatedDense(self.args.z1_size, 300)) self.p_x_layers_z2 = nn.Sequential(GatedDense(self.args.z2_size, 300)) self.p_x_layers_joint_pre = nn.Sequential( GatedDense(2 * 300, np.prod(self.args.input_size))) # decoder: p(x | z) act = nn.ReLU(True) # joint self.p_x_layers_joint = nn.Sequential( GatedConv2d(self.args.input_size[0], 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), ) if self.args.input_type == 'binary': self.p_x_mean = Conv2d(64, 1, 1, 1, 0, activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Sigmoid()) self.p_x_logvar = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Hardtanh(min_val=-4.5, max_val=0.)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) self.args = args # encoder: q(z2 | x) self.q_z2_layers = nn.Sequential( nn.Dropout(p=0.5), NonLinear(np.prod(self.args.input_size), self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh()), ) self.q_z2_mean = Linear(self.args.hidden_size, self.args.z2_size) self.q_z2_logvar = NonLinear(self.args.hidden_size, self.args.z2_size, activation=nn.Hardtanh(min_val=-12., max_val=4.)) # encoder: q(z1 | x, z2) self.q_z1_layers_x = nn.Sequential(nn.Dropout(p=0.5), ) self.q_z1_layers_z2 = nn.Sequential() self.q_z1_layers_joint = nn.Sequential( NonLinear(np.prod(self.args.input_size) + self.args.z2_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh())) self.q_z1_mean = Linear(self.args.hidden_size, self.args.z1_size) self.q_z1_logvar = NonLinear(self.args.hidden_size, self.args.z1_size, activation=nn.Hardtanh(min_val=-12., max_val=4.)) # decoder: p(z1 | z2) self.p_z1_layers = nn.Sequential( NonLinear(self.args.z2_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh()), ) self.p_z1_mean = Linear(self.args.hidden_size, self.args.z1_size) self.p_z1_logvar = NonLinear(self.args.hidden_size, self.args.z1_size, activation=nn.Hardtanh(min_val=-12., max_val=4.)) # decoder: p(x | z1, z2) self.p_x_layers_z1 = nn.Sequential() self.p_x_layers_z2 = nn.Sequential() self.p_x_layers_joint = nn.Sequential( NonLinear(self.args.z1_size + self.args.z2_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh())) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=nn.Sigmoid()) if self.args.input_type == 'multinomial': self.p_x_mean = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=None) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=nn.Hardtanh(min_val=-4.5, max_val=0)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs for VampPrior self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) # encoder: q(z | x) modules = [ nn.Dropout(p=0.5), NonLinear(np.prod(self.args.input_size), self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh()) ] for _ in range(0, self.args.num_layers - 1): modules.append( NonLinear(self.args.hidden_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh())) self.q_z_layers = nn.Sequential(*modules) self.q_z_mean = Linear(self.args.hidden_size, self.args.z1_size) self.q_z_logvar = NonLinear(self.args.hidden_size, self.args.z1_size, activation=nn.Hardtanh(min_val=-12., max_val=4.)) # decoder: p(x | z) modules = [ NonLinear(self.args.z1_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh()) ] for _ in range(0, self.args.num_layers - 1): modules.append( NonLinear(self.args.hidden_size, self.args.hidden_size, gated=self.args.gated, activation=nn.Tanh())) self.p_x_layers = nn.Sequential(*modules) if self.args.input_type == 'binary': self.p_x_mean = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=nn.Sigmoid()) if self.args.input_type == 'multinomial': self.p_x_mean = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=None) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=nn.Sigmoid()) self.p_x_logvar = NonLinear(self.args.hidden_size, np.prod(self.args.input_size), activation=None) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs for VampPrior self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) if self.args.dataset_name == 'freyfaces': h_size = 210 elif self.args.dataset_name == 'cifar10': h_size = 384 else: h_size = 294 # encoder: q(z2 | x) self.q_z2_layers = nn.Sequential( GatedConv2d(self.args.input_size[0], 32, 7, 1, 3), GatedConv2d(32, 32, 3, 2, 1), GatedConv2d(32, 64, 5, 1, 2), GatedConv2d(64, 64, 3, 2, 1), GatedConv2d(64, 6, 3, 1, 1) ) # linear layers self.q_z2_mean = NonLinear(h_size, self.args.z2_size, activation=None) self.q_z2_logvar = NonLinear(h_size, self.args.z2_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # encoder: q(z1|x,z2) # PROCESSING x self.q_z1_layers_x = nn.Sequential( GatedConv2d(self.args.input_size[0], 32, 3, 1, 1), GatedConv2d(32, 32, 3, 2, 1), GatedConv2d(32, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 2, 1), GatedConv2d(64, 6, 3, 1, 1) ) # PROCESSING Z2 self.q_z1_layers_z2 = nn.Sequential( GatedDense(self.args.z2_size, h_size) ) # PROCESSING JOINT self.q_z1_layers_joint = nn.Sequential( GatedDense( 2 * h_size, 300) ) # linear layers self.q_z1_mean = NonLinear(300, self.args.z1_size, activation=None) self.q_z1_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder p(z1|z2) self.p_z1_layers = nn.Sequential( GatedDense(self.args.z2_size, 300), GatedDense(300, 300) ) self.p_z1_mean = NonLinear(300, self.args.z1_size, activation=None) self.p_z1_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder: p(x | z) self.p_x_layers_z1 = nn.Sequential( GatedDense(self.args.z1_size, 300) ) self.p_x_layers_z2 = nn.Sequential( GatedDense(self.args.z2_size, 300) ) self.p_x_layers_joint_pre = nn.Sequential( GatedDense(2 * 300, np.prod(self.args.input_size)) ) # decoder: p(x | z) act = nn.ReLU(True) # joint self.p_x_layers_joint = nn.Sequential( GatedConv2d(self.args.input_size[0], 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), ) if self.args.input_type == 'binary': self.p_x_mean = Conv2d(64, 1, 1, 1, 0, activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Sigmoid()) self.p_x_logvar = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Hardtanh(min_val=-4.5, max_val=0.)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) if self.args.dataset_name == 'freyfaces': h_size = 210 elif self.args.dataset_name.startswith( 'cifar10' ) or self.args.dataset_name == 'coil20' or self.args.dataset_name == 'svhn': h_size = 384 elif self.args.dataset_name == 'usps': h_size = 96 elif args.dataset_name == 'celeba': h_size = 1536 else: h_size = 294 # encoder: q(z | x) self.q_z_layers = nn.Sequential( GatedConv2d(self.args.input_size[0], 32, 7, 1, 3), GatedConv2d(32, 32, 3, 2, 1), GatedConv2d(32, 64, 5, 1, 2), GatedConv2d(64, 64, 3, 2, 1), GatedConv2d(64, 6, 3, 1, 1)) self.q_z_mean = NonLinear(h_size, self.args.z1_size, activation=None) self.q_z_logvar = NonLinear(h_size, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) self.fc = nn.Sequential(GatedDense(self.args.z1_size, 300), GatedDense(300, np.prod(self.args.input_size))) self.p_x_layers = nn.Sequential( GatedConv2d(self.args.input_size[0], 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), GatedConv2d(64, 64, 3, 1, 1), ) if self.args.input_type == 'binary': self.p_x_mean = Conv2d(64, 1, 1, 1, 0, activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Sigmoid()) self.p_x_logvar = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Hardtanh(min_val=-4.5, max_val=0.)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) # encoder: q(z | x) if self.args.dataset_name == 'freyfaces': h_size = 210 elif self.args.dataset_name == 'cifar10': h_size = 384 elif self.args.dataset_name == 'svhn': h_size = 384 else: h_size = 294 # encoder: q(z2 | x) self.q_z_layers = nn.Sequential( Conv2d(self.args.input_size[0], 32, 7, 1, 3, activation=nn.ReLU()), nn.BatchNorm2d(32), Conv2d(32, 32, 3, 2, 1, activation=nn.ReLU()), nn.BatchNorm2d(32), Conv2d(32, 64, 5, 1, 2, activation=nn.ReLU()), nn.BatchNorm2d(64), Conv2d(64, 64, 3, 2, 1, activation=nn.ReLU()), nn.BatchNorm2d(64), Conv2d(64, 6, 3, 1, 1, activation=nn.ReLU())) ''' self.q_z_layers = [NonGatedDense(np.prod(self.args.input_size), 300, activation=nn.ReLU())] for i in range(args.number_hidden): self.q_z_layers.append(NonGatedDense(300, 300, activation=nn.ReLU())) self.q_z_layers = nn.ModuleList(self.q_z_layers) ''' self.q_z_mean = Linear(h_size, self.args.z1_size) self.q_z_logvar = Linear( h_size, self.args.z1_size ) #NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6.,max_val=2.)) # decoder: p(x | z) self.p_x_layers = [ NonGatedDense(self.args.z1_size, 300, activation=nn.ReLU()) ] for i in range(args.number_hidden): self.p_x_layers.append( NonGatedDense(300, 300, activation=nn.ReLU())) self.p_x_layers.append( NonGatedDense(300, np.prod(self.args.input_size), activation=nn.ReLU())) self.p_x_layers = nn.ModuleList(self.p_x_layers) # PixelCNN act = nn.ReLU(True) self.pixelcnn = nn.Sequential( MaskedConv2d('A', self.args.input_size[0] + self.args.input_size[0], 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64), act) if self.args.input_type == 'binary': self.p_x_mean = Conv2d(64, 1, 1, 1, 0, activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Sigmoid(), bias=False) self.p_x_logvar = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Hardtanh(min_val=-4.5, max_val=0.), bias=False) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) else: if torch.is_tensor(m): torch.nn.init.kaiming_normal(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) if self.args.dataset_name == 'freyfaces': h_size = 210 elif self.args.dataset_name == 'cifar10': h_size = 384 else: h_size = 294 # encoder: q(z2 | x) self.q_z2_layers = nn.ModuleList() # conv 0 self.q_z2_layers.append( GatedConv2d(self.args.input_size[0], 32, 5, 1, 3)) # conv 1 self.q_z2_layers.append(GatedConv2d(32, 32, 5, 2, 1)) # conv 2 self.q_z2_layers.append(GatedConv2d(32, 64, 5, 1, 3)) # conv 3 self.q_z2_layers.append(GatedConv2d(64, 64, 5, 2, 1)) # conv 4 self.q_z2_layers.append(GatedConv2d(64, 6, 3, 1, 1)) # linear layers self.q_z2_mean = NonLinear(h_size, self.args.z2_size, activation=None) self.q_z2_logvar = NonLinear(h_size, self.args.z2_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # encoder: q(z1|x,z2) self.q_z1_layers_x = nn.ModuleList() self.q_z1_layers_z2 = nn.ModuleList() self.q_z1_layers_joint = nn.ModuleList() # PROCESSING x # conv 0 self.q_z1_layers_x.append( GatedConv2d(self.args.input_size[0], 32, 5, 1, 3)) # conv 1 self.q_z1_layers_x.append(GatedConv2d(32, 32, 5, 2, 1)) # conv 2 self.q_z1_layers_x.append(GatedConv2d(32, 64, 5, 1, 3)) # conv 3 self.q_z1_layers_x.append(GatedConv2d(64, 64, 5, 2, 1)) # conv 7 self.q_z1_layers_x.append(GatedConv2d(64, 6, 3, 1, 1)) # PROCESSING Z2 self.q_z1_layers_z2.append(GatedDense(self.args.z2_size, h_size)) # PROCESSING JOINT self.q_z1_layers_joint.append(GatedDense(2 * h_size, 300)) # linear layers self.q_z1_mean = NonLinear(300, self.args.z1_size, activation=None) self.q_z1_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder p(z1|z2) self.p_z1_layers = nn.ModuleList() self.p_z1_layers.append(GatedDense(self.args.z2_size, 300)) self.p_z1_layers.append(GatedDense(300, 300)) self.p_z1_mean = NonLinear(300, self.args.z1_size, activation=None) self.p_z1_logvar = NonLinear(300, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder: p(x | z) self.p_x_layers_z1 = nn.ModuleList() self.p_x_layers_z2 = nn.ModuleList() self.p_x_layers_z1.append( GatedDense(self.args.z1_size, np.prod(self.args.input_size))) self.p_x_layers_z2.append( GatedDense(self.args.z2_size, np.prod(self.args.input_size))) # PixelCNN act = nn.ReLU() self.pixelcnn = nn.Sequential( MaskedConv2d('A', self.args.input_size[0] + 2 * self.args.input_size[0], 64, 5, 1, 2, bias=True), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 5, 1, 2, bias=True), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 5, 1, 2, bias=True), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 5, 1, 2, bias=True), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 5, 1, 2, bias=True), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 5, 1, 2, bias=True), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 5, 1, 2, bias=True), nn.BatchNorm2d(64), act, MaskedConv2d('B', 64, 64, 5, 1, 2, bias=True), nn.BatchNorm2d(64), act) if self.args.input_type == 'binary': self.p_x_mean = Conv2d(64, 1, 1, 1, 0, activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Sigmoid()) self.p_x_logvar = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Hardtanh(min_val=-4.5, max_val=0.)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()
def __init__(self, args): super(VAE, self).__init__(args) h_size = 512 nc = self.args.input_size[0] # number of channels nz = self.args.z1_size # size of latent vector ngf = 64 # decoder (generator) filter factor ndf = 64 # encoder filter factor self.q_z_layers = nn.Sequential( # input is (nc) x 64 x 64 nn.Conv2d(nc, ndf, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf) x 32 x 32 nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 2), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*2) x 16 x 16 nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 4), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*4) x 8 x 8 nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 8), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*8) x 4 x 4 nn.Conv2d(ndf * 8, ndf * 8, 4, 1, 0, bias=False)) # linear layers self.q_z_mean = NonLinear(h_size, self.args.z1_size, activation=None) self.q_z_logvar = NonLinear(h_size, self.args.z1_size, activation=nn.Hardtanh(min_val=-6., max_val=2.)) # decoder: p(x | z) self.p_x_layers_z = nn.Sequential(GatedDense(self.args.z1_size, h_size)) # decoder: p(x | z) act = nn.ReLU(True) # joint self.p_x_layers_joint = nn.Sequential( # input is Z, going into a convolution nn.ConvTranspose2d(h_size, ngf * 8, 4, 1, 0, bias=False), nn.BatchNorm2d(ngf * 8), nn.ReLU(True), # state size. (ngf*8) x 4 x 4 nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf * 4), nn.ReLU(True), # state size. (ngf*4) x 8 x 8 nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf * 2), nn.ReLU(True), # state size. (ngf*2) x 16 x 16 nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf), nn.ReLU(True), # state size. (ngf) x 32 x 32 nn.ConvTranspose2d(ngf, ngf, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf), nn.ReLU(True) # state size. (nc) x 64 x 64 ) if self.args.input_type == 'binary': self.p_x_mean = Conv2d(64, 1, 1, 1, 0, activation=nn.Sigmoid()) elif self.args.input_type == 'gray' or self.args.input_type == 'continuous': self.p_x_mean = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Sigmoid()) self.p_x_logvar = Conv2d(64, self.args.input_size[0], 1, 1, 0, activation=nn.Hardtanh(min_val=-4.5, max_val=0.)) # weights initialization for m in self.modules(): if isinstance(m, nn.Linear): he_init(m) # add pseudo-inputs if VampPrior if self.args.prior == 'vampprior': self.add_pseudoinputs()