def predict_cost(operator, params):
# apply lstm architecture to compute operator tree embedding
_, r_out = predict_representation(operator, params)
# estimation network to get costs
hidden_layer = leaky_relu(r_out, params['w_est_h1'])
return leaky_relu(hidden_layer, params['w_est_final'])
def create_deconv(input,
in_channels,
out_channels,
input_image_size,
weight_set=[],
no_bias=False):
# # reverse max-pooling using densely connected layer:
# dense = tf.reshape(input, [-1, in_channels * image_size**2])
# new_image_size = image_size*2
# w1 = weight_var([in_channels * image_size**2, in_channels * new_image_size**2])
# img = tf.reshape(tf.matmul(dense, w1), [-1, new_image_size, new_image_size, in_channels])
#
input = batch_norm(input)
w = weight_var([patch_size, patch_size, out_channels, in_channels])
weight_set.append(w)
b = weight_var([out_channels], init_zero=no_bias)
if not no_bias:
weight_set.append(b)
batch_size = tf.shape(input)[0]
output_shape = tf.pack([
batch_size, input_image_size * 2, input_image_size * 2,
out_channels
])
deconv = tf.nn.conv2d_transpose(input,
w,
output_shape,
strides=[1, 2, 2, 1],
padding='SAME')
return leaky_relu(deconv + b)
def create_fc(input, out_size, weight_set=[]):
# input_dropped = tf.nn.dropout(input, dropout_keep_prob)
in_size = input.get_shape()[-1]
w = weight_var([in_size, out_size], stddev=0.1)
weight_set.append(w)
b = weight_var([out_size], stddev=0)
weight_set.append(b)
x = tf.matmul(input, w)
return leaky_relu(x + b)
def create_conv(input, in_channels, out_channels, weight_set=[]):
input = batch_norm(input, variables_collections=[weight_set])
w = weight_var([patch_size, patch_size, in_channels, out_channels])
b = weight_var([out_channels])
weight_set.append(w)
weight_set.append(b)
conv = tf.nn.conv2d(input, w, strides=[1, 2, 2, 1], padding='SAME')
activation = leaky_relu(conv + b)
return activation
def predict_embedding(node, params):
embedding_op = leaky_relu(node.operator_feature, params['w_emd_op'])
embedding_table = leaky_relu(node.table_feature, params['w_emd_t'])
embedding_sample = leaky_relu(node.sample_bitmap, params['w_emd_s'])
embedding_predicate = np.zeros((1, node.dim_predicate_embedding))
for predicate_vector in node.predicates_list:
current_embedding = leaky_relu(predicate_vector, params['w_emd_p'])
embedding_predicate = np.maximum(embedding_predicate,
current_embedding)
for predicate_vector in node.join_predicates_list:
current_embedding = leaky_relu(predicate_vector, params['w_emd_jp'])
embedding_predicate = np.maximum(embedding_predicate,
current_embedding)
embedding = np.concatenate(
(embedding_op, embedding_table, embedding_sample, embedding_predicate),
axis=1)
return embedding
def create_conv(input, out_channels, patch_size=2, stride=2, weight_set=[]):
in_channels = input.get_shape()[-1]
w = weight_var([patch_size, patch_size, in_channels, out_channels],
stddev=0.1)
b = weight_var([out_channels], stddev=0)
conv = tf.nn.conv2d(input,
w,
strides=[1, stride, stride, 1],
padding='SAME')
activation = leaky_relu(conv + b) # tf.nn.relu(conv + b)
weight_set.append(w)
weight_set.append(b)
return activation
def create_conv_with_pooling(input,
in_channels,
out_channels,
weight_set=[]):
w = weight_var([patch_size, patch_size, in_channels, out_channels])
b = weight_var([out_channels], init_zero=True)
conv = tf.nn.conv2d(input, w, strides=[1, 1, 1, 1], padding='SAME')
activation = leaky_relu(conv + b)
weight_set.append(w)
weight_set.append(b)
pooled = tf.nn.max_pool(activation,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
return pooled
def create_dense(input,
in_size,
out_size,
weight_set=[],
relu=True,
no_bias=False):
input = batch_norm(input)
input_dropped = tf.nn.dropout(input, disc_dropout_keep_prob)
w = weight_var([in_size, out_size])
weight_set.append(w)
b = weight_var([out_size], init_zero=no_bias)
if not no_bias:
weight_set.append(b)
x = tf.matmul(input_dropped, w)
return leaky_relu(x + b) if relu else x + b
def create_deconv(input, out_channels, patch_size=2, stride=2, weight_set=[]):
# stride should be multiple of patch_size for best results
in_channels = input.get_shape()[-1]
input_image_width, input_image_height = input_image_size.get_shape()[2:4]
w = weight_var([patch_size, patch_size, out_channels, in_channels])
weight_set.append(w)
b = weight_var([out_channels], init_zero=no_bias)
weight_set.append(b)
batch_size = tf.shape(input)[0]
output_shape = tf.pack([
batch_size, input_image_width * stride, input_image_height * stride,
out_channels
])
deconv = tf.nn.conv2d_transpose(input,
w,
output_shape,
strides=[1, stride, stride, 1],
padding='SAME')
return leaky_relu(deconv + b)
def generator_caffenet_fc6(input_feat, reuse=False, trainable=False):
with tf.variable_scope('generator', reuse=reuse) as vs:
assert input_feat.get_shape().as_list()[-1] == 4096
# input_feat = tf.placeholder(tf.float32, shape=(None, 4096), name='feat')
relu_defc7 = leaky_relu(
fc(input_feat, 4096, name='defc7', trainable=trainable))
relu_defc6 = leaky_relu(
fc(relu_defc7, 4096, name='defc6', trainable=trainable))
relu_defc5 = leaky_relu(
fc(relu_defc6, 4096, name='defc5', trainable=trainable))
reshaped_defc5 = tf.reshape(relu_defc5, [-1, 256, 4, 4])
relu_deconv5 = leaky_relu(
upconv(tf.transpose(reshaped_defc5, perm=[0, 2, 3, 1]),
256,
4,
2,
'deconv5',
biased=True,
trainable=trainable))
relu_conv5_1 = leaky_relu(
upconv(relu_deconv5,
512,
3,
1,
'conv5_1',
biased=True,
trainable=trainable))
relu_deconv4 = leaky_relu(
upconv(relu_conv5_1,
256,
4,
2,
'deconv4',
biased=True,
trainable=trainable))
relu_conv4_1 = leaky_relu(
upconv(relu_deconv4,
256,
3,
1,
'conv4_1',
biased=True,
trainable=trainable))
relu_deconv3 = leaky_relu(
upconv(relu_conv4_1,
128,
4,
2,
'deconv3',
biased=True,
trainable=trainable))
relu_conv3_1 = leaky_relu(
upconv(relu_deconv3,
128,
3,
1,
'conv3_1',
biased=True,
trainable=trainable))
deconv2 = leaky_relu(
upconv(relu_conv3_1,
64,
4,
2,
'deconv2',
biased=True,
trainable=trainable))
deconv1 = leaky_relu(
upconv(deconv2,
32,
4,
2,
'deconv1',
biased=True,
trainable=trainable))
deconv0 = upconv(deconv1,
3,
4,
2,
'deconv0',
biased=True,
trainable=trainable)
variables = tf.contrib.framework.get_variables(vs)
return deconv0, variables, [
relu_defc7, relu_defc6, relu_defc5, reshaped_defc5, relu_deconv5,
relu_conv5_1, relu_deconv4, relu_conv4_1, relu_deconv3, relu_conv3_1,
deconv2, deconv1, deconv0
]
