def get_global_energy(self,
xinput=None,
yinput=None,
embedding=None,
reuse=False):
with tf.variable_scope(self.config.en_variable_scope) as scope:
j = 0
net = yinput
for (sz, a) in self.config.en_layer_info:
net = tflearn.fully_connected(
net,
sz,
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
regularizer='L2',
# activation=a,
scope=("en.h" + str(j)))
net = tf.log(tf.exp(net) + 1.0)
j = j + 1
global_e = tflearn.fully_connected(
net,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.zeros(),
bias=False,
reuse=reuse,
regularizer='L2',
scope=("en.g"))
return tf.squeeze(global_e)
def softmax_prediction_network2(self, xinput=None, reuse=False):
net = xinput
print("xinput", xinput)
with tf.variable_scope("pred") as scope:
net = tflearn.fully_connected(
net,
1000,
regularizer='L2',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("ph.0"))
net = tf.nn.relu(net)
net = tflearn.layers.dropout(net, 1 - self.config.dropout)
net = tflearn.fully_connected(
net,
self.config.output_num * self.config.dimension,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
regularizer='L2',
scope=("ph.1"))
cat_output = tf.reshape(
net, (-1, self.config.output_num, self.config.dimension))
return tf.nn.softmax(cat_output, dim=2)
def softmax_prediction_network(self, hidden_vars, reuse=False):
net = hidden_vars
with tf.variable_scope(self.config.spen_variable_scope):
with tf.variable_scope("pred") as scope:
net = tflearn.fully_connected(
net,
100,
activation='relu',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("ph.0"))
net = tflearn.fully_connected(
net,
self.config.output_num * self.config.dimension,
activation='softplus',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("ph.1"))
cat_output = tf.reshape(
net, (-1, self.config.output_num, self.config.dimension))
#return tf.nn.so(cat_output, dim=2)
return tf.nn.softmax(cat_output, dim=2)
def cnn_prediction_network(self, xinput=None, reuse=False):
# input = tf.concat((xinput, yinput), axis=1)
net = xinput
j = 0
with tf.variable_scope("pred"):
net = tf.reshape(net,
shape=(-1, self.config.image_width,
self.config.image_height, 1))
for (nf, fs, st) in self.config.cnn_layer_info:
net = tflearn.conv_2d(net,
nb_filter=nf,
filter_size=fs,
strides=st,
padding="same",
scope=("conv" + str(j)),
activation=tf.nn.relu,
reuse=reuse)
# net = tflearn.max_pool_2d(net, kernel_size=[2,2], strides=2)
# net = tflearn.batch_normalization(net, scope=("bn"+ str(j)), reuse=reuse)
j = j + 1
j = 0
for (sz, a) in self.config.pred_layer_info:
net = tflearn.fully_connected(
net,
sz,
regularizer='L2',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("ph." + str(j)))
net = tf.nn.relu(net)
net = tflearn.layers.dropout(net, 1 - self.config.dropout)
j = j + 1
net = tflearn.fully_connected(
net,
self.config.output_num * self.config.dimension,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
regularizer='L2',
scope=("ph.fc"))
if self.config.dimension == 1:
return tf.nn.sigmoid(net)
else:
cat_output = tf.reshape(
net, (-1, self.config.output_num, self.config.dimension))
return tf.nn.softmax(cat_output, dim=2)
def get_energy_mlp(self,
xinput=None,
yinput=None,
embedding=None,
reuse=False):
output_size = yinput.get_shape().as_list()[-1]
with tf.variable_scope(self.config.spen_variable_scope):
with tf.variable_scope(self.config.fx_variable_scope) as scope:
logits = self.get_feature_net_mlp(xinput,
output_size,
reuse=reuse)
mult = tf.multiply(logits, yinput)
local_e = tflearn.fully_connected(
mult,
1,
activation='linear',
regularizer='L2',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=False,
bias_init=tfi.zeros(),
reuse=reuse,
scope=("en.l"))
with tf.variable_scope(self.config.en_variable_scope) as scope:
j = 0
net = yinput
for (sz, a) in self.config.en_layer_info:
net = tflearn.fully_connected(
net,
sz,
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
regularizer='L2',
scope=("en.h" + str(j)))
# net = tflearn.dropout(net, 1.0 - self.config.dropout)
# net = tflearn.layers.normalization.batch_normalization(net, reuse=reuse, scope=("bn.f" + str(j)))
# net = tflearn.activations.softplus(net)
net = tf.log(tf.exp(net) + 1.0)
j = j + 1
global_e = tflearn.fully_connected(
net,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.zeros(),
bias=False,
reuse=reuse,
regularizer='L2',
scope=("en.g"))
return tf.squeeze(local_e + global_e)
def get_feature_net_mlp(self, xinput, output_num, reuse=False):
print(output_num)
net = xinput
j = 0
for (sz, a) in self.config.layer_info:
print(sz, a)
net = tflearn.fully_connected(
net,
sz,
weight_decay=self.config.weight_decay,
# weights_init=tfi.variance_scaling(,
bias_init=tfi.zeros(),
regularizer='L2',
reuse=reuse,
scope=("fx.h" + str(j)))
net = tflearn.activations.relu(net)
# net = tflearn.dropout(net, 1.0 - self.config.dropout)
j = j + 1
logits = tflearn.fully_connected(net,
output_num,
activation='linear',
regularizer='L2',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=False,
reuse=reuse,
scope=("fx.h" + str(j)))
return logits
def mlp_prediction_network(self, xinput=None, reuse=False):
net = xinput
j = 0
with tf.variable_scope("pred") as scope:
for (sz, a) in self.config.pred_layer_info:
print(sz, a)
net = tflearn.fully_connected(
net,
sz,
regularizer='L2',
activation=a,
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("ph." + str(j)))
net = tflearn.layers.dropout(net, 1 - self.config.dropout)
j = j + 1
logits = tflearn.fully_connected(
net,
self.config.output_num * self.config.dimension,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
reuse=reuse,
bias=False,
regularizer='L2',
scope=("ph.fc"))
# if self.config.dimension == 1:
# return tf.nn.sigmoid(net)
# else:
# cat_output = tf.reshape(net, (-1, self.config.output_num, self.config.dimension))
# return tf.nn.softmax(cat_output, dim=2)
return logits
def get_feature_net_mlp(self,
xinput,
output_num,
embedding=None,
reuse=False):
net = xinput
j = 0
for (sz, a) in self.config.layer_info:
net = tflearn.fully_connected(
net,
sz,
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
regularizer='L2',
reuse=reuse,
scope=("fx.h" + str(j)))
# net = tflearn.layers.normalization.batch_normalization(net, reuse=reuse, scope=("bn.f" + str(j)))
net = tflearn.activations.relu(net)
j = j + 1
logits = tflearn.fully_connected(net,
output_num,
activation='linear',
regularizer='L2',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=False,
reuse=reuse,
scope=("fx.h" + str(j)))
return logits
def get_network():
biases = zeros(shape=[9, 19, 1, 192])
biases2 = zeros(shape=[19, 19, 1])
network = input_data(shape=[None, 19, 19, 2], name='input')
network = conv_2d(network, 192, 5, activation='elu', weights_init=truncated_normal(stddev=stddev5), bias=False) + biases[0]
network = conv_2d(network, 192, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases[1]
network = conv_2d(network, 192, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases[2]
network = conv_2d(network, 192, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases[3]
network = conv_2d(network, 192, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases[4]
network = conv_2d(network, 192, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases[5]
network = conv_2d(network, 192, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases[6]
network = conv_2d(network, 192, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases[7]
network = conv_2d(network, 192, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases[8]
network = conv_2d(network, 1, 3, activation='elu', weights_init=truncated_normal(stddev=stddev3), bias=False) + biases2
network = fully_connected(network, 19*19, activation='softmax')
momentum = Momentum(learning_rate=0.002)
network = regression(network, optimizer=momentum, loss='categorical_crossentropy', name='target')
return network
def get_feature_net_cnn(self, input, output_num, reuse=False):
net = input
netw = tf.nn.embedding_lookup(self.W, net)
net_expanded = tf.expand_dims(netw, -1)
pooled_outputs = []
for i, filter_size in enumerate(self.config.filter_sizes):
with tf.variable_scope("max-pooling") as scope:
if reuse:
scope.reuse_variables()
filter_shape = [
filter_size, self.embedding_size, 1,
self.config.num_filters
]
W = tf.get_variable(
initializer=tf.truncated_normal(filter_shape, stddev=0.1),
name=("W" + ("-conv-maxpool-%s" % filter_size)))
b = tf.get_variable(
initializer=tf.constant(0.1,
shape=[self.config.num_filters]),
name=("b" + ("-conv-maxpool-%s" % filter_size)))
conv = tf.nn.conv2d(net_expanded,
W,
strides=[1, 1, 1, 1],
padding="VALID",
name=("conv" +
("-conv-maxpool-%s" % filter_size)))
# Apply nonlinearity
h = tf.nn.relu(tf.nn.bias_add(conv, b), name="relu")
# Max-pooling over the outputs
pooled = tf.nn.max_pool(
h,
ksize=[1, self.sequence_length - filter_size + 1, 1, 1],
strides=[1, 1, 1, 1],
padding='VALID',
name="pool")
pooled_outputs.append(pooled)
num_filters_total = self.config.num_filters * len(
self.config.filter_sizes)
h_pool = tf.concat(pooled_outputs, 3)
net = tf.reshape(h_pool, [-1, num_filters_total])
net = tflearn.dropout(net, 1.0 - self.config.dropout)
j = 0
net2 = netw
sz = self.config.output_num
logits = tflearn.fully_connected(net,
sz,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("fx.h-cnn" + str(j)))
return logits
def construct_embedding(self, embedding_size, vocabulary_size):
self.vocabulary_size = vocabulary_size
self.embedding_size = embedding_size
self.embedding_placeholder = tf.placeholder(tf.float32, [self.vocabulary_size, self.embedding_size])
with tf.variable_scope(self.config.spen_variable_scope) as scope:
self.embedding = tf.get_variable("emb", shape=[self.vocabulary_size, self.embedding_size], dtype=tf.float32,
initializer=tfi.zeros(), trainable=True)
self.embedding_init = self.embedding.assign(self.embedding_placeholder)
return self
def get_energy_rnn_emb(self, xinput, yinput, embedding=None, reuse=False):
xinput = tf.cast(xinput, tf.int32)
xinput = tf.nn.embedding_lookup(embedding, xinput)
with tf.variable_scope(self.config.spen_variable_scope):
with tf.variable_scope(self.config.fx_variable_scope) as scope:
logits = self.get_feature_net_rnn(xinput, reuse=reuse)
mult = tf.multiply(logits, yinput)
local_e = tflearn.fully_connected(
mult,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=None,
bias_init=tfi.zeros(),
reuse=reuse,
scope=("en.l"))
#with tf.variable_scope(self.config.en_variable_scope) as scope:
# net = yinput
# j = 0
# for (sz, a) in self.config.en_layer_info:
# net = tflearn.fully_connected(net, sz,activation=a,
# weight_decay=self.config.weight_decay,
# weights_init=tfi.variance_scaling(),
# bias_init=tfi.zeros(), reuse=reuse,
# scope=("en.h" + str(j)))
# j = j + 1
# global_e = tflearn.fully_connected(net, 1, activation='linear', weight_decay=self.config.weight_decay,
# weights_init=tfi.zeros(),
# bias_init=tfi.zeros(), reuse=reuse,
# scope="en.g")
#net = global_e + local_e
net = local_e
return tf.squeeze(net)
def cnn_javier(self, xinput=None, reuse=False):
net = tf.reshape(xinput, (-1, 32, 64, 1))
prev_nFilter = 0
with tf.variable_scope("pred"):
for j, (nFilter, kSz,
strides) in enumerate(self.config.cnn_layer_info):
if j == 0:
net = tflearn.conv_2d(net,
1,
3,
reuse=False,
scope="baseline.h{}".format(j),
bias=True)
else:
net = tflearn.conv_2d(net,
prev_nFilter,
3,
strides=strides,
reuse=False,
scope="baseline.h{}".format(j),
activation='relu',
bias=True)
prev_nFilter = nFilter
sz = self.config.output_num
std = 1.0 / np.sqrt(sz)
probs = tflearn.fully_connected(
net,
sz,
activation='sigmoid',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
regularizer='L2',
reuse=False,
scope=("baseline.fc"))
return probs
def horses_network(self, xinput=None, reuse=False):
net = xinput
j = 0
with tf.variable_scope("pred"):
net = tf.reshape(net,
shape=(-1, self.config.image_width,
self.config.image_height, 3))
net = tf.reshape(net,
shape=(-1, self.config.image_width,
self.config.image_height, 3))
net = tf.layers.conv2d(inputs=net,
filters=64,
kernel_size=[3, 3],
strides=1,
padding="same",
name="conv0",
activation=tf.nn.relu,
reuse=reuse)
net = tf.layers.conv2d(inputs=net,
filters=64,
strides=2,
kernel_size=[3, 3],
padding="same",
name="conv1",
activation=tf.nn.relu,
reuse=reuse)
# net = tf.layers.batch_normalization()
# net = tf.layers.max_pooling2d(inputs=net, pool_size=[2, 2], strides=2, name="pool1")
# net = tflearn.local_response_normalization(net)
# net = tflearn.dropout(net, 0.8)
net = tf.layers.conv2d(inputs=net,
filters=128,
kernel_size=[3, 3],
padding="same",
name="conv2",
strides=2,
activation=tf.nn.relu,
reuse=reuse)
# net = tf.layers.max_pooling2d(inputs=net, pool_size=[2, 2], strides=2, name="pool2")
# net = tflearn.local_response_normalization(net)
# net = tflearn.dropout(net, 0.8)
net = tf.layers.conv2d(inputs=net,
filters=128,
kernel_size=[3, 3],
padding="same",
name="conv3",
strides=2,
activation=tf.nn.relu,
reuse=reuse)
# net = tf.layers.max_pooling2d(inputs=net, pool_size=[2, 2], strides=2, name="pool3")
# net = tflearn.local_response_normalization(net)
# net = tflearn.dropout(net, 0.8)
# net = tf.reshape(net, [-1, (self.config.image_width / 8) * (self.config.image_height / 8) * 128])
net = tf.layers.flatten(net)
# net = tf.layers.max_pooling2d(inputs=net, pool_size=[2, 2], strides=2, name="pool3")
net = tflearn.dropout(net, 1.0 - self.config.dropout)
j = 0
for (sz, a) in self.config.layer_info:
net = tflearn.fully_connected(
net,
sz,
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
activation=a,
bias_init=tfi.zeros(),
regularizer='L2',
reuse=reuse,
scope=("fx.h" + str(j)))
net = tflearn.dropout(net, 1.0 - self.config.dropout)
# net = tflearn.layers.dropout(net, 1 - self.config.dropout)
j = j + 1
logits = tflearn.fully_connected(
net,
self.config.output_num * self.config.dimension,
activation='linear',
regularizer='L2',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=False,
reuse=reuse,
scope=("fx.fc"))
return logits
def mlph_prediction_network(self, xinput=None, reuse=False):
hpart = xinput[:, :self.config.hidden_num]
xpart = xinput[:, self.config.hidden_num:]
with tf.variable_scope("hpred") as scope:
hnet = tflearn.fully_connected(
hpart,
200,
regularizer='L2',
activation='relu',
weight_decay=self.config.weight_decay,
weights_init=tfi.zeros(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("f.h0"))
with tf.variable_scope("xpred") as scope:
xnet = tflearn.fully_connected(
xpart,
1024,
regularizer='L2',
activation='relu',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("f.x0"))
j = 0
net = tf.concat((hnet, xnet), axis=1)
with tf.variable_scope("pred") as scope:
for (sz, a) in self.config.pred_layer_info:
print(sz, a)
net = tflearn.fully_connected(
net,
sz,
regularizer='L2',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("ph." + str(j)))
net = tf.nn.relu(net)
net = tflearn.layers.dropout(net, 1 - self.config.dropout)
j = j + 1
net = tflearn.fully_connected(
net,
self.config.output_num * self.config.dimension,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
reuse=reuse,
bias=False,
regularizer='L2',
scope=("ph.fc"))
if self.config.dimension == 1:
return tf.nn.sigmoid(net)
else:
cat_output = tf.reshape(
net, (-1, self.config.output_num, self.config.dimension))
return tf.nn.softmax(cat_output, dim=2)
def energy_cnn_image(self,
xinput=None,
yinput=None,
embedding=None,
reuse=False):
image_size = tf.cast(tf.sqrt(tf.cast(tf.shape(xinput)[1], tf.float64)),
tf.int32)
output_size = yinput.get_shape().as_list()[-1]
with tf.variable_scope(self.config.spen_variable_scope):
xinput = tf.reshape(xinput, shape=(-1, image_size, image_size))
conv1 = tf.layers.conv2d(inputs=tf.expand_dims(xinput, axis=3),
filters=8,
kernel_size=[3, 3],
padding="same",
name="conv1",
activation=tf.nn.relu,
reuse=reuse)
conv1 = tf.nn.dropout(conv1, 1.0 - self.config.dropout)
pool1 = tf.layers.max_pooling2d(inputs=conv1,
pool_size=[2, 2],
strides=2,
name="spen/pool1")
conv2 = tf.layers.conv2d(inputs=pool1,
filters=16,
kernel_size=[3, 3],
padding="same",
name="conv2",
activation=tf.nn.relu,
reuse=reuse)
conv2 = tf.nn.dropout(conv2, 1.0 - self.config.dropout)
pool2 = tf.layers.max_pooling2d(inputs=conv2,
pool_size=[2, 2],
strides=2,
name="spen/pool2")
conv3 = tf.layers.conv2d(inputs=pool2,
filters=32,
kernel_size=[3, 3],
padding="same",
name="conv3",
activation=tf.nn.relu,
reuse=reuse)
conv3 = tf.nn.dropout(conv3, 1.0 - self.config.dropout)
pool3 = tf.layers.max_pooling2d(inputs=conv3,
pool_size=[2, 2],
strides=2,
name="spen/pool3")
self.state_dim = 3200
self.encode_embeddings = tf.reshape(pool3, [-1, self.state_dim])
with tf.variable_scope(self.config.fx_variable_scope):
logits = self.get_feature_net_mlp(self.encode_embeddings,
output_size,
reuse=reuse)
mult = tf.multiply(logits, yinput)
local_e = tflearn.fully_connected(
mult,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=None,
bias_init=tfi.zeros(),
reuse=reuse,
scope="en.l")
with tf.variable_scope(self.config.en_variable_scope) as scope:
net = yinput
j = 0
for (sz, a) in self.config.en_layer_info:
net = tflearn.fully_connected(
net,
sz,
activation=a,
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("en.h" + str(j)))
j = j + 1
global_e = tflearn.fully_connected(
net,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.zeros(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("en.h" + str(j)))
net = local_e + global_e
return tf.squeeze(net)
def get_energy_rnn_mlp_emb(self,
xinput,
yinput,
embedding=None,
reuse=False):
xinput = tf.cast(xinput, tf.int32)
xinput = tf.nn.embedding_lookup(embedding, xinput)
output_size = yinput.get_shape().as_list()[-1]
with tf.variable_scope(self.config.spen_variable_scope):
with tf.variable_scope(self.config.fx_variable_scope) as scope:
logits2 = self.get_feature_net_rnn(xinput, reuse=reuse)
logits3 = self.get_feature_net_mlp(xinput,
output_size,
reuse=reuse) #+ logits2
#mult_ = tf.multiply(logits, yinput)
mult2 = tf.multiply(logits2, yinput)
mult3 = tf.multiply(logits3, yinput)
local_e3 = tflearn.fully_connected(
mult3,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=None,
bias_init=tfi.zeros(),
reuse=reuse,
scope=("fx3.b0"))
local_e2 = tflearn.fully_connected(
mult2,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=None,
bias_init=tfi.zeros(),
reuse=reuse,
scope=("fx2.b0"))
#local_e = tflearn.fully_connected(mult_, 1, activation='linear', weight_decay=self.config.weight_decay,
# weights_init=tfi.variance_scaling(),
# bias=None,
# bias_init=tfi.zeros(), reuse=reuse, scope=("fx.b0"))
j = 0
with tf.variable_scope(self.config.en_variable_scope) as scope:
net = yinput
j = 0
for (sz, a) in self.config.en_layer_info:
# std = np.sqrt(2.0) / np.sqrt(sz)
net = tflearn.fully_connected(
net,
sz,
activation=a,
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("en.h" + str(j)))
# net = tflearn.activations.relu(net)
#net = tflearn.layers.normalization.batch_normalization(net, reuse=reuse, scope=("bn.en" + str(j)))
j = j + 1
global_e = tflearn.fully_connected(
net,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.zeros(),
bias_init=tfi.zeros(),
reuse=reuse,
scope=("en.h" + str(j)))
# en = tflearn.layers.normalization.batch_normalization(en, reuse=ru, scope=("en." + str(j)))
if reuse:
scope.reuse_variables()
net = global_e + local_e3 + local_e2 #+ local_e + local_e3
return tf.squeeze(net)
def get_energy_mlp(self,
xinput=None,
yinput=None,
embedding=None,
reuse=False):
output_size = yinput.get_shape().as_list()[-1]
with tf.variable_scope(self.config.spen_variable_scope):
with tf.variable_scope(self.config.fx_variable_scope) as scope:
net = xinput
j = 0
for (sz, a) in self.config.layer_info:
net = tflearn.fully_connected(
net,
sz,
weight_decay=self.config.weight_decay,
activation=a,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
regularizer='L2',
reuse=reuse,
scope=("fx.h" + str(j)))
net = tflearn.dropout(net, 1.0 - self.config.dropout)
j = j + 1
logits = tflearn.fully_connected(
net,
output_size,
activation='linear',
regularizer='L2',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias_init=tfi.zeros(),
reuse=reuse,
scope="fx.fc")
mult = logits * yinput
local_e = tf.reduce_sum(mult, axis=1)
with tf.variable_scope(self.config.en_variable_scope) as scope:
j = 0
net = yinput
for (sz, a) in self.config.en_layer_info:
net = tflearn.fully_connected(
net,
sz,
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
activation=a,
bias=False,
reuse=reuse,
regularizer='L2',
scope=("en.h" + str(j)))
j = j + 1
global_e = tf.squeeze(
tflearn.fully_connected(net,
1,
activation='linear',
weight_decay=self.config.weight_decay,
weights_init=tfi.variance_scaling(),
bias=False,
reuse=reuse,
regularizer='L2',
scope=("en.g")))
return tf.squeeze(tf.add(local_e, global_e))
