def generator(input_shape, dimH, dimZ, dimY, n_channel, last_activation, name): # first construct p(y|z) fc_layers = [dimZ, dimH, dimY] pyz_mlp_layers = [] N_layers = len(fc_layers) - 1 l = 0 for i in range(N_layers): name_layer = name + '_pyz_mlp_l%d' % l if i + 1 == N_layers: activation = 'linear' else: activation = 'relu' pyz_mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer)) def pyz_params(z): out = z for layer in pyz_mlp_layers: out = layer(out) return out # now construct p(z|x) # encoder for z (low res) layer_channels = [n_channel for i in range(3)] filter_width = 5 filter_shapes = construct_filter_shapes(layer_channels, filter_width) fc_layer_sizes = [dimH] gen_conv2, conv_output_shape = ConvNet(name+'_pzx_conv', input_shape, filter_shapes, \ fc_layer_sizes, 'relu', last_activation = 'relu') print('generator shared Conv net ' + ' network architecture:', \ conv_output_shape, fc_layer_sizes) fc_layers = [dimH, dimH, dimZ * 2] pzx_mlp_layers = [] N_layers = len(fc_layers) - 1 l = 0 for i in range(N_layers): name_layer = name + '_pzx_mlp_l%d' % l if i + 1 == N_layers: activation = 'linear' else: activation = 'relu' pzx_mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer)) def pzx_params(x): out = gen_conv2(x) for layer in pzx_mlp_layers: out = layer(out) mu, log_sig = tf.split(out, 2, axis=1) return mu, log_sig return pyz_params, pzx_params
def generator(dimX, dimH, dimZ, dimY, last_activation, name): # first construct p(y|z) fc_layers = [dimZ, dimH, dimY] pyz_mlp_layers = [] N_layers = len(fc_layers) - 1 l = 0 for i in range(N_layers): name_layer = name + '_pyz_mlp_l%d' % l if i + 1 == N_layers: activation = 'linear' else: activation = 'relu' with tf.variable_scope('vae'): pyz_mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer)) def pyz_params(z): out = z for layer in pyz_mlp_layers: out = layer(out) return out # now construct p(z|x) fc_layers = [dimX, dimH, dimH, dimZ * 2] l = 0 pzx_mlp_layers = [] N_layers = len(fc_layers) - 1 for i in range(N_layers): if i < N_layers - 1: activation = 'relu' else: activation = 'linear' name_layer = name + '_pzx_mlp_l%d' % l with tf.variable_scope('vae'): pzx_mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer)) l += 1 def pzx_params(x): out = x for layer in pzx_mlp_layers: out = layer(out) mu, log_sig = tf.split(out, 2, axis=1) return mu, log_sig return pyz_params, pzx_params
def generator(dimX, dimH, dimZ, dimY, last_activation, name): # first construct p(y|z) fc_layers = [dimZ, dimH, dimH, dimY] pyz_mlp_layers = [] N_layers = len(fc_layers) - 1 l = 0 for i in range(N_layers): name_layer = name + '_pyz_mlp_l%d' % l if i + 1 == N_layers: activation = 'linear' else: activation = 'relu' with tf.variable_scope('vae'): pyz_mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer)) def pyz_params(z): out = z for layer in pyz_mlp_layers: out = layer(out) return out # now construct p(x|z) fc_layers = [dimZ, dimH, dimH, dimX] l = 0 pxz_mlp_layers = [] N_layers = len(fc_layers) - 1 for i in range(N_layers): if i < N_layers - 1: activation = 'relu' else: activation = last_activation name_layer = name + '_pxz_mlp_l%d' % l with tf.variable_scope('vae'): pxz_mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer)) l += 1 def pxz_params(z): out = z for layer in pxz_mlp_layers: out = layer(out) return out return pyz_params, pxz_params
def generator(dimX, dimH, dimZ, last_activation, name, bin_num=2): # construct p(x|z) fc_layers = [dimZ, dimH, dimH, dimX * bin_num] l = 0 pxz_mlp_layers = [] N_layers = len(fc_layers) - 1 for i in range(N_layers): if i < N_layers - 1: activation = 'relu' else: activation = last_activation name_layer = name + '_pxz_mlp_l%d' % l with tf.variable_scope('vae'): pxz_mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer)) l += 1 def pxz_params(z): out = z for layer in pxz_mlp_layers: out = layer(out) out = tf.reshape(out, [-1, 3514, bin_num]) return out return pxz_params
def encoder_convnet(input_shape, dimH, dimZ, dimY, n_channel, dropout, name): # encoder for z (low res) layer_channels = [n_channel for i in range(3)] filter_width = 5 filter_shapes = construct_filter_shapes(layer_channels, filter_width) fc_layer_sizes = [dimH] enc_conv, conv_output_shape = ConvNet(name+'_conv', input_shape, filter_shapes, \ fc_layer_sizes, 'relu', last_activation = 'relu', dropout = dropout) print('encoder shared Conv net ' + ' network architecture:', \ conv_output_shape, fc_layer_sizes) fc_layer = [dimH + dimY, dimH, dimZ] enc_mlp = [] for i in range(len(fc_layer) - 1): if i + 2 < len(fc_layer): activation = 'relu' else: activation = 'linear' name_layer = name + '_mlp_l%d' % i enc_mlp.append( mlp_layer(fc_layer[i], fc_layer[i + 1], activation, name_layer)) def apply_conv(x): return enc_conv(x) def apply_mlp(x, y): out = tf.concat([x, y], 1) for layer in enc_mlp: out = layer(out) return out return apply_conv, apply_mlp
def generator_head(dimZ, dimH, n_layers, name): fc_layer_sizes = [dimZ] + [dimH for i in range(n_layers)] layers = [] N_layers = len(fc_layer_sizes) - 1 for i in range(N_layers): d_in = fc_layer_sizes[i]; d_out = fc_layer_sizes[i+1] name_layer = name + '_head_l%d' % i layers.append(mlp_layer(d_in, d_out, 'relu', name_layer)) print 'decoder head MLP of size', fc_layer_sizes def apply(x): for layer in layers: x = layer(x) return x return apply
def encoder_shared(dimX, dimH, n_layers, name): fc_layer_sizes = [dimX] + [dimH for i in range(n_layers)] layers = [] N_layers = len(fc_layer_sizes) - 1 for i in range(N_layers): d_in = fc_layer_sizes[i]; d_out = fc_layer_sizes[i+1] name_layer = name + '_shared_l%d' % i layers.append(mlp_layer(d_in, d_out, 'relu', name_layer)) print 'encoder shared MLP of size', fc_layer_sizes def apply(x): for layer in layers: x = layer(x) return x return apply
def encoder_net(dimX, dimH, dimZ, n_layers, name): fc_layer = [dimX] + [dimH for i in range(n_layers)] + [dimZ] enc_mlp = [] for i in range(len(fc_layer) - 1): if i + 2 < len(fc_layer): activation = 'relu' else: activation = 'linear' name_layer = name + '_mlp_l%d' % i with tf.variable_scope('vae'): enc_mlp.append( mlp_layer(fc_layer[i], fc_layer[i + 1], activation, name_layer)) def apply_mlp(x): out = tf.concat([x], 1) for layer in enc_mlp: out = layer(out) return out return apply_mlp
def encoder_head(dimH, dimZ, n_layers, name): fc_layer_sizes = [dimH for i in range(n_layers)] + [dimZ*2] layers = [] N_layers = len(fc_layer_sizes) - 1 for i in range(N_layers): d_in = fc_layer_sizes[i]; d_out = fc_layer_sizes[i+1] name_layer = name + '_head_l%d' % i if i < N_layers - 1: activation = 'relu' else: activation = 'linear' layers.append(mlp_layer(d_in, d_out, activation, name_layer)) print 'encoder head MLP of size', fc_layer_sizes def apply(x): for layer in layers: x = layer(x) return x return apply
def encoder(dimX, dimH, dimZ, n_layers, name): fc_layer_sizes = [dimX] + [dimH for i in xrange(n_layers)] + [dimZ*2] layers = [] N_layers = len(fc_layer_sizes) - 1 for i in xrange(N_layers): d_in = fc_layer_sizes[i]; d_out = fc_layer_sizes[i+1] name_layer = name + '_l%d' % i if i < N_layers - 1: activation = 'relu' else: activation = 'linear' layers.append(mlp_layer(d_in, d_out, activation, name_layer)) print 'encoder shared MLP of size', fc_layer_sizes def apply(x): for layer in layers: x = layer(x) mu, log_sig = tf.split(x, 2, axis=1) return mu, log_sig return apply
def generator_shared(dimX, dimH, n_layers, last_activation, name): # now construct a decoder fc_layer_sizes = [dimH for i in range(n_layers)] + [dimX] layers = [] N_layers = len(fc_layer_sizes) - 1 for i in range(N_layers): d_in = fc_layer_sizes[i]; d_out = fc_layer_sizes[i+1] if i < N_layers - 1: activation = 'relu' else: activation = last_activation name_layer = name + '_shared_l%d' % i layers.append(mlp_layer(d_in, d_out, activation, name_layer)) print 'decoder shared MLP of size', fc_layer_sizes def apply(x): for layer in layers: x = layer(x) return x return apply
def generator(input_shape, dimH, dimZ, dimY, n_channel, last_activation, name): # first construct p(y|z) fc_layers = [dimZ, dimH, dimY] pyz_mlp_layers = [] N_layers = len(fc_layers) - 1 l = 0 for i in range(N_layers): name_layer = name + '_pzy_l%d' % l if i+1 == N_layers: activation = 'linear' else: activation = 'relu' pyz_mlp_layers.append(mlp_layer(fc_layers[i], fc_layers[i+1], activation, name_layer)) def pyz_params(z): out = z for layer in pyz_mlp_layers: out = layer(out) return out # now construct p(x|z, y) filter_width = 5 decoder_input_shape = [(4, 4, n_channel), (7, 7, n_channel), (14, 14, n_channel)] decoder_input_shape.append(input_shape) fc_layers = [dimZ+dimY, dimH, int(np.prod(decoder_input_shape[0]))] l = 0 # first include the MLP mlp_layers = [] N_layers = len(fc_layers) - 1 for i in range(N_layers): name_layer = name + '_l%d' % l mlp_layers.append(mlp_layer(fc_layers[i], fc_layers[i+1], 'relu', name_layer)) l += 1 conv_layers = [] N_layers = len(decoder_input_shape) - 1 for i in range(N_layers): if i < N_layers - 1: activation = 'relu' else: activation = last_activation name_layer = name + '_l%d' % l output_shape = decoder_input_shape[i+1] input_shape = decoder_input_shape[i] up_height = int(np.ceil(output_shape[0]/float(input_shape[0]))) up_width = int(np.ceil(output_shape[1]/float(input_shape[1]))) strides = (1, up_height, up_width, 1) if activation in ['logistic_cdf', 'gaussian'] and i == N_layers - 1: # ugly wrapping for logistic cdf likelihoods activation = 'split' output_shape = (output_shape[0], output_shape[1], output_shape[2]*2) filter_shape = (filter_width, filter_width, output_shape[-1], input_shape[-1]) conv_layers.append(deconv_layer(output_shape, filter_shape, activation, \ strides, name_layer)) l += 1 print('decoder shared Conv Net of size', decoder_input_shape) def pxzy_params(z, y): x = tf.concat([z, y], 1) for layer in mlp_layers: x = layer(x) x = tf.reshape(x, (x.get_shape().as_list()[0],)+decoder_input_shape[0]) for layer in conv_layers: x = layer(x) return x return pyz_params, pxzy_params
def generator(input_shape, dimH, dimZ, dimY, n_channel, last_activation, name): # first construct p(y|z, x) # encoder for z (low res) layer_channels = [n_channel, n_channel * 2, n_channel * 4] filter_width = 5 filter_shapes = construct_filter_shapes(layer_channels, filter_width) fc_layer_sizes = [dimH] gen_conv, conv_output_shape = ConvNet(name+'_pyzx_conv', input_shape, filter_shapes, \ fc_layer_sizes, 'relu', last_activation = 'relu') print('generator shared Conv net ' + ' network architecture:', \ conv_output_shape, fc_layer_sizes) fc_layers = [dimZ + dimH, dimH, dimY] pyzx_mlp_layers = [] N_layers = len(fc_layers) - 1 l = 0 for i in range(N_layers): name_layer = name + '_pyzx_mlp_l%d' % l if i + 1 == N_layers: activation = 'linear' else: activation = 'relu' pyzx_mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer)) def pyzx_params(z, x): fea = gen_conv(x) out = tf.concat([fea, z], axis=1) for layer in pyzx_mlp_layers: out = layer(out) return out # now construct p(x|z) filter_width = 5 decoder_input_shape = [(4, 4, n_channel * 4), (8, 8, n_channel * 2), (16, 16, n_channel)] decoder_input_shape.append(input_shape) fc_layers = [dimZ, dimH, int(np.prod(decoder_input_shape[0]))] l = 0 # first include the MLP mlp_layers = [] N_layers = len(fc_layers) - 1 for i in range(N_layers): name_layer = name + '_l%d' % l mlp_layers.append( mlp_layer(fc_layers[i], fc_layers[i + 1], 'relu', name_layer)) l += 1 conv_layers = [] N_layers = len(decoder_input_shape) - 1 for i in range(N_layers): if i < N_layers - 1: activation = 'relu' else: activation = last_activation name_layer = name + '_l%d' % l output_shape = decoder_input_shape[i + 1] input_shape = decoder_input_shape[i] up_height = int(np.ceil(output_shape[0] / float(input_shape[0]))) up_width = int(np.ceil(output_shape[1] / float(input_shape[1]))) strides = (1, up_height, up_width, 1) if activation in [ 'logistic_cdf', 'gaussian' ] and i == N_layers - 1: # ugly wrapping for logistic cdf likelihoods activation = 'split' output_shape = (output_shape[0], output_shape[1], output_shape[2] * 2) filter_shape = (filter_width, filter_width, output_shape[-1], input_shape[-1]) conv_layers.append(deconv_layer(output_shape, filter_shape, activation, \ strides, name_layer)) l += 1 print('decoder shared Conv Net of size', decoder_input_shape) def pxz_params(z): x = z for layer in mlp_layers: x = layer(x) x = tf.reshape(x, (x.get_shape().as_list()[0], ) + decoder_input_shape[0]) for layer in conv_layers: x = layer(x) return x return pyzx_params, pxz_params