def _build(self):
input_image = ph.placeholder('input_image',
(None, vgg.HEIGHT, vgg.WIDTH, 3),
ph.float)
encoder = vgg.VGG16('encoder')
encoder.setup(input_image)
h = encoder['h7']
dropout = ph.Dropout('dropout')
h = dropout.setup(h)
dense = ph.Linear('dense', encoder.fc7.output_size, self._num_classes)
y = dense.setup(h)
y = tf.nn.softmax(y)
label = tf.argmax(y, axis=1)
self.predict = ph.Step(inputs=input_image,
outputs=(label, y),
givens={dropout.keep_prob: 1.0})
input_label = ph.placeholder('input_label', (None, ), ph.int)
y_target = tf.one_hot(input_label, self._num_classes)
loss = ph.ops.cross_entropy(y_target, y)
loss = tf.reduce_mean(loss)
var_list = dense.get_trainable_variables()
reg = ph.reg.L2Regularizer(1e-6)
reg.setup(var_list)
grad_list = [
tf.clip_by_value(grad, -10, 10)
for grad in tf.gradients(loss + reg.get_loss(), var_list)
]
lr = ph.train.ExponentialDecayedValue('lr_train',
1e-4,
num_loops=1e4,
min_value=1e-5)
update = tf.train.AdamOptimizer(lr.value).apply_gradients(
zip(grad_list, var_list))
self.train = ph.Step(inputs=(input_image, input_label),
outputs=loss,
updates=(update, lr.update_op),
givens={dropout.keep_prob: self._keep_prob})
var_list = self.get_trainable_variables()
reg = ph.reg.L2Regularizer(1e-7)
reg.setup(var_list)
grad_list = [
tf.clip_by_value(grad, -10, 10)
for grad in tf.gradients(loss + reg.get_loss(), var_list)
]
lr = ph.train.ExponentialDecayedValue('lr_fine_tune',
2e-5,
num_loops=3e4,
min_value=1e-6)
update = tf.train.AdamOptimizer(lr.value).apply_gradients(
zip(grad_list, var_list))
self.fine_tune = ph.Step(inputs=(input_image, input_label),
outputs=loss,
updates=(update, lr.update_op),
givens={dropout.keep_prob: self._keep_prob})
def _build(self):
image = ph.placeholder('input_image', (None, vgg.HEIGHT, vgg.WIDTH, 3),
ph.float)
encoder = vgg.VGG16('encoder')
encoder.setup(image)
h = encoder['h7']
dropout = ph.Dropout('dropout')
h = dropout.setup(h)
dense = ph.Linear('dense', encoder.fc7.output_size, NUM_CLASSES)
y = dense.setup(h)
y = tf.nn.sigmoid(y)
self.predict = ph.Step(inputs=image,
outputs=y,
givens={dropout.keep_prob: 1.0})
target = ph.placeholder('target', (None, NUM_CLASSES), ph.float)
loss = ph.ops.cross_entropy(target, y)
loss = tf.reduce_mean(loss)
var_list = dense.get_trainable_variables()
reg = ph.reg.L2Regularizer(1e-6)
reg.setup(var_list)
grad_list = [
tf.clip_by_value(grad, -10, 10)
for grad in tf.gradients(loss + reg.get_loss(), var_list)
]
lr = ph.train.ExponentialDecayedValue('lr_train',
1e-4,
num_loops=3e3,
min_value=1e-5)
update = tf.train.AdamOptimizer(lr.value).apply_gradients(
zip(grad_list, var_list))
self.train = ph.Step(inputs=(image, target),
outputs=loss,
updates=update,
givens={dropout.keep_prob: self._keep_prob})
var_list = self.get_trainable_variables()
reg = ph.reg.L2Regularizer(1e-7)
reg.setup(var_list)
grad_list = [
tf.clip_by_value(grad, -10, 10)
for grad in tf.gradients(loss + reg.get_loss(), var_list)
]
lr = ph.train.ExponentialDecayedValue('lr_fine_tune',
2e-5,
num_loops=2e4,
min_value=1e-6)
update = tf.train.AdamOptimizer(lr.value).apply_gradients(
zip(grad_list, var_list))
self.fine_tune = ph.Step(inputs=(image, target),
outputs=loss,
updates=update,
givens={dropout.keep_prob: self._keep_prob})
def _build(self):
self._step_get_state = ph.Step(inputs=(*self._input_list,
self._prev_state),
outputs=self._state)
#
# reset gradient
grad_zeros_list = [
tf.zeros(shape=var_.shape,
dtype=var_.dtype,
name='grad_' + ph.utils.get_basename(var_.name) + '_init')
for var_ in self._var_list
]
self._grad_acc_list = [
ph.variable(name='grad_' + ph.utils.get_basename(grad_zero.name),
initial_value=grad_zero,
trainable=False) for grad_zero in grad_zeros_list
]
self._step_reset_grad = ph.Step(updates=tf.group(*[
tf.assign(grad, value)
for grad, value in zip(self._grad_acc_list, grad_zeros_list)
]))
#
# update gradient
grad_state = ph.placeholder(
name='grad_' + ph.utils.get_basename(self._prev_state.name),
shape=self._prev_state.shape,
dtype=self._prev_state.dtype)
grad_weight = ph.placeholder('grad_weight', ())
grad_list = tf.gradients(self._state, self._var_list, grad_state)
grad_prev_state = tf.gradients(self._state, [self._prev_state],
grad_state)[0]
self._step_update_grad = ph.Step(
inputs=(*self._input_list, self._prev_state, grad_state,
grad_weight),
outputs=(grad_prev_state, tf.reduce_sum(tf.abs(grad_prev_state))),
updates=tf.group(*[
tf.assign_add(grad_acc, grad * grad_weight)
for grad_acc, grad in zip(self._grad_acc_list, grad_list)
]))
#
# apply gradient
self._step_apply_grad = ph.Step(
updates=self._optimizer.apply_gradients(
zip(self._grad_acc_list, self._var_list)))
def __init__(self, name, state_size, action_size, hidden_size=64):
super(Agent, self).__init__(
name,
ph.placeholder('source_state', (None, state_size)),
ph.placeholder('target_state', (None, state_size)),
ph.placeholder('reward', (None, )),
actors_critics.DeepResActor('source_actor', state_size,
action_size, hidden_size, 6),
actors_critics.DeepResActor('target_actor', state_size,
action_size, hidden_size, 6),
actors_critics.DeepResCritic('source_critic', state_size,
action_size, hidden_size, 6),
actors_critics.DeepResCritic('target_critic', state_size,
action_size, hidden_size, 6),
gamma=0.9,
replay_size=1000,
optimizer=tf.train.RMSPropOptimizer(1e-4, 0.9, 0.9))
def _build(self):
encoder = vgg.VGG16('encoder')
image = ph.placeholder('image', (None, vgg.HEIGHT, vgg.WIDTH, 3),
ph.float)
encoder.setup(image)
h7 = encoder['h7']
self.step = ph.Step(inputs=image, outputs=h7)
self.predict = self.step
def __init__(self, name, state_size, action_size, hidden_size=64):
super(Agent, self).__init__(
name,
ph.placeholder('source_state', (None, state_size)),
ph.placeholder('target_state', (None, state_size)),
ph.placeholder('reward', (None, )),
actors_critics.DeepResActor('source_actor', state_size,
action_size, hidden_size, 6),
actors_critics.DeepResActor('target_actor', state_size,
action_size, hidden_size, 6),
actors_critics.DeepResCritic('source_critic', state_size,
action_size, hidden_size, 6),
actors_critics.DeepResCritic('target_critic', state_size,
action_size, hidden_size, 6),
# actors_critics.MLPActor('source_actor', state_size, action_size, hidden_size),
# actors_critics.MLPActor('target_actor', state_size, action_size, hidden_size),
# actors_critics.MLPCritic('source_critic', state_size, action_size, hidden_size * 2),
# actors_critics.MLPCritic('target_critic', state_size, action_size, hidden_size * 2),
replay_size=10000)
def _build(self):
x = ph.placeholder('x', shape=(None, self._input_size), dtype=ph.float)
hidden_layer = ph.Linear('hidden_layer',
input_size=self._input_size,
output_size=self._hidden_size)
out_layer = ph.Linear('out_layer',
input_size=self._hidden_size,
output_size=self._num_classes)
dropout = ph.Dropout('dropout')
y = ph.setup(
x, [hidden_layer, ph.ops.lrelu, dropout, out_layer, tf.nn.softmax])
label = tf.argmax(y, axis=1)
self.predict = ph.Step(inputs=x,
outputs=(label, y),
givens={dropout.keep_prob: 1.0})
true_label = ph.placeholder('true_label', shape=(None, ), dtype=ph.int)
target = tf.one_hot(true_label, self._num_classes)
loss = ph.ops.cross_entropy(target, y)
loss = tf.reduce_mean(loss)
var_list = self.get_trainable_variables()
reg = ph.reg.L2Regularizer(1e-6)
reg.setup(var_list)
grad_list = [
tf.clip_by_value(grad, -10, 10)
for grad in tf.gradients(loss + reg.get_loss(), var_list)
]
lr = ph.train.ExponentialDecayedValue('lr_train',
1e-4,
num_loops=2e4,
min_value=1e-6)
update = tf.train.AdamOptimizer(lr.value).apply_gradients(
zip(grad_list, var_list))
self.train = ph.Step(inputs=(x, true_label),
outputs=loss,
updates=(update, lr.update_op),
givens={dropout.keep_prob: self._keep_prob})
def _build(self):
encoder = Encoder('seq_encoder', self._voc_size, self._emb_size,
self._state_size)
decoder = Decoder('seq_decoder', self._voc_size, self._emb_size,
self._state_size, encoder.emb_layer)
self._encoder = encoder
self._decoder = decoder
seq = ph.placeholder('seq', (None, None, self._voc_size))
max_len = tf.shape(seq)[1]
h = encoder.setup(seq)
seq_ = decoder.setup(h, max_len)
self._seq = seq
self._h = h
self._seq_ = seq_
loss = -ph.ops.log_likelihood(seq, seq_,
reduce=False) # (batch_size, seq_length)
seq_len = ph.ops.sequence_length(seq)
mask = tf.sequence_mask(seq_len,
dtype=ph.dtype) # (batch_size, seq_length)
loss = ph.ops.reduce_sum_loss(loss * mask)
self._loss = loss
reg = ph.reg.Regularizer()
reg.add_l1_l2(self.get_trainable_variables())
update = self._optimizer.minimize(
loss + reg.get_loss(self._reg) if self._reg > 0 else loss)
self.train = ph.Step(inputs=seq,
outputs={
'seq_': seq_,
'loss': loss
},
updates=update)
self.test = ph.Step(inputs=seq,
outputs={
'h': h,
'seq_': seq_,
'loss': loss
})
def _build(self):
encoder = Encoder(
'dc_encoder',
self._height, self._width, self._channels,
self._emb_size,
self._num_layers, self._kernel_size, self._channels1
)
decoder = Decoder(
'dc_decoder',
self._height, self._width, self._channels,
self._emb_size,
self._num_layers, self._kernel_size, self._channels1
)
self._encoder = encoder
self._decoder = decoder
x = ph.placeholder('x', (None, self._height, self._width, self._channels))
h = encoder.setup(x, activation=ph.lrelu)
x_ = decoder.setup(h, activation=ph.lrelu)
self._x = x
self._h = h
self._x_ = x_
loss = tf.reduce_mean((x_ - x) ** 2)
self._loss = loss
reg = ph.Regularizer()
reg.add_l1_l2(self.get_trainable_variables())
update = self._optimizer.minimize(loss + reg.get_loss(self._reg) if self._reg > 0 else loss)
self._add_slot(
ph.TRAIN,
inputs=x,
outputs={'y': x_, 'loss': loss},
updates=update
)
self._add_slot(
ph.PREDICT,
inputs=x,
outputs={'h': h, 'y': x_, 'loss': loss}
)
def _build(self):
encoder = Encoder('seq_encoder', self._voc_size, self._emb_size,
self._state_size)
decoder = Decoder('seq_decoder', self._voc_size, self._emb_size,
self._state_size, self._encoder.emb_layer)
self._encoder = encoder
self._decoder = decoder
seq = ph.placeholder('seq', (None, None, self._voc_size))
max_len = tf.shape(seq)[1]
h = encoder.setup(seq)
seq_ = decoder.setup(h, max_len)
self._seq = seq
self._h = h
self._seq_ = seq_
loss = -(seq * ph.log(1 - seq_) + (1 - seq) * ph.log(seq_))
loss = tf.reduce_mean(loss)
self._loss = loss
reg = ph.Regularizer()
reg.add_l1_l2(self.get_trainable_variables())
update = self._optimizer.minimize(
loss + reg.get_loss(self._reg) if self._reg > 0 else loss)
self._add_slot(ph.TRAIN,
inputs=seq,
outputs={
'seq_': seq_,
'loss': loss
},
updates=update)
self._add_slot(ph.PREDICT,
inputs=seq,
outputs={
'h': h,
'seq_': seq_,
'loss': loss
})
def _build(self):
input_x = tf.tile(self._input_x, [self._num_mc_samples] + [1] * (len(self._input_x.shape) - 1))
g_net = self._glimpse_network
l_net = self._location_network
input_stddev = tf.placeholder(
shape=(),
dtype=ph.dtype,
name='input_stddev'
)
cell = self._cell = ph.GRUCell(
'cell',
g_net.output_size,
self._state_size,
w_init=ph.init.GlorotUniform()
)
batch_size = tf.shape(input_x)[0]
init_state = tf.zeros(shape=(batch_size, self._state_size), dtype=ph.dtype)
init_loc = tf.random_uniform((batch_size, 2), minval=-1, maxval=1)
def _loop(acc, _):
prev_state, loc, _ = acc
g = g_net.setup(input_x, loc)
state = cell.setup(g, prev_state)
next_loc, next_mean = l_net.setup(state, input_stddev)
return state, next_loc, next_mean
states, locs, means = tf.scan(
fn=_loop,
elems=tf.zeros(shape=(self._num_steps,), dtype=tf.int8),
initializer=(init_state, init_loc, init_loc)
) # (num_steps, batch_size, *)
baseline_layer = self._baseline_layer = ph.Linear('baseline_layer', self._state_size, 1)
def _make_baseline(state):
baseline = baseline_layer.setup(state) # (batch_size, 1)
baseline = tf.reshape(baseline, (-1,)) # (batch_size,)
return baseline
baselines = tf.map_fn(_make_baseline, states) # (num_steps, batch_size)
baselines = tf.transpose(baselines) # (batch_size, num_steps)
predict_layer = self._predict_layer = ph.Linear('predict_layer', self._state_size, self._num_classes)
last_state = states[-1] # (batch_size, state_size)
prob = predict_layer.setup(last_state)
prob = tf.nn.softmax(prob) # (batch_size, num_classes)
label = tf.argmax(prob, 1) # (batch_size,)
self._step_predict = ph.Step(
inputs=input_x,
outputs=label,
givens={input_stddev: 1e-3}
)
self._input_label = ph.placeholder('input_label', (None,), tf.int64)
input_label = tf.tile(self._input_label, (self._num_mc_samples,))
prob_ = tf.one_hot(input_label, self._num_classes) # (batch_size, num_classes)
predict_loss = self._predict_loss = -tf.reduce_mean(ph.ops.log_likelihood(prob_, prob))
reward = tf.cast(tf.equal(label, input_label), tf.float32) # (batch_size,)
rewards = tf.reshape(reward, (-1, 1)) # (batch_size, 1)
rewards = tf.tile(rewards, (1, self._num_steps)) # (batch_size, num_steps)
rewards = tf.stop_gradient(rewards)
baseline_loss = self._baseline_loss = tf.reduce_mean(ph.ops.mean_square_error(rewards, baselines))
advantages = rewards - tf.stop_gradient(baselines)
logll = self._log_gaussian(locs, means, input_stddev)
logll = tf.reduce_sum(logll, 2) # (num_steps, batch_size)
logll = tf.transpose(logll) # (batch_size, num_steps)
logll_ratio = self._logll_ratio = tf.reduce_mean(logll * advantages)
loss = self._loss = predict_loss - logll_ratio + baseline_loss
if self._reg is not None:
self._reg.setup(self.get_trainable_variables())
update = self._optimizer.minimize(loss + self._reg.get_loss())
else:
update = self._optimizer.minimize(loss)
self._step_train = ph.Step(
inputs=(self._input_x, self._input_label),
outputs=(loss, tf.reduce_mean(rewards)),
updates=update,
givens={input_stddev: self._stddev}
)
def _build(self):
input_image = ph.placeholder('input_image',
(None, alexnet.HEIGHT, alexnet.WIDTH, 3),
ph.float)
encoder = alexnet.AlexNet('encoder', ph.ops.swish)
dropout = ph.Dropout('dropout')
dense = ph.Linear('dense', encoder['dense_7'].output_size,
self._hidden_size)
output_layer = ph.Linear('output_layer', dense.output_size,
self._num_classes + 1)
encoder.setup(input_image)
y = ph.setup(
encoder['feature_7'],
[dense, ph.ops.swish, dropout, output_layer, tf.nn.softmax])
label = tf.argmax(y, axis=1)
self.predict = ph.Step(inputs=input_image,
outputs=(label, y),
givens={dropout.keep_prob: 1.0})
input_label = ph.placeholder('input_label', (None, ), ph.int)
y_target = tf.one_hot(input_label, self._num_classes + 1)
loss = -ph.ops.log_likelihood(y_target, y)
loss = tf.reduce_mean(loss)
################################################################################
# pre-train
################################################################################
vars_new = [
*dense.get_trainable_variables(),
*output_layer.get_trainable_variables()
]
reg = ph.reg.L2Regularizer(self._reg)
reg.setup(vars_new)
lr = ph.train.ExponentialDecayedValue('lr_1',
init_value=self._learning_rate_1,
num_loops=self._num_loops_1,
min_value=self._learning_rate_1 /
10)
update_1 = tf.train.AdamOptimizer(lr.value).apply_gradients([
(tf.clip_by_value(g, -self._grad_clip, self._grad_clip), v)
for g, v in zip(tf.gradients(loss +
reg.get_loss(), vars_new), vars_new)
if g is not None
])
# with tf.control_dependencies([update_1]):
# update_2 = ph.train.L2Regularizer(self._reg).apply(vars_new)
self.train = ph.Step(inputs=(input_image, input_label),
outputs=(loss, lr.variable),
updates=update_1,
givens={dropout.keep_prob: self._keep_prob})
################################################################################
# fine tune
################################################################################
vars_all = self.get_trainable_variables()
reg = ph.reg.L2Regularizer(self._reg)
reg.setup(vars_all)
lr = ph.train.ExponentialDecayedValue('lr_2',
init_value=self._learning_rate_2,
num_loops=self._num_loops_2,
min_value=self._learning_rate_2 /
10)
update_1 = tf.train.AdamOptimizer(lr.value).apply_gradients([
(tf.clip_by_value(g, -self._grad_clip, self._grad_clip), v)
for g, v in zip(tf.gradients(loss +
reg.get_loss(), vars_all), vars_all)
if g is not None
])
# with tf.control_dependencies([update_1]):
# update_2 = ph.train.L2Regularizer(self._reg).apply(vars_all)
self.fine_tune = ph.Step(inputs=(input_image, input_label),
outputs=(loss, lr.variable),
updates=update_1,
givens={dropout.keep_prob: self._keep_prob})
def _build(self):
shared = Embedding('shared', self._wemb_size, 500, act)
specific = Embedding('specific', self._wemb_size, 500)
gate = ph.Gate('gate', (500, 500), 500)
lin = ph.Linear('lin', 500, 1000)
out = ph.Linear('out', 1000, 2)
stat = VectorStat('stat')
drop = ph.Dropout('drop')
#
seq = ph.placeholder('seq', (None, None, self._wemb_size))
h1, states1 = shared.setup(seq)
stat.setup(tf.reshape(seq, (-1, self._wemb_size), name='flat_seq'))
stat.setup(tf.reshape(states1, (-1, 500), name='flat_states'))
h2, _ = specific.setup(seq)
g = gate.setup(h1, h2)
h = g * h1 + (1.0 - g) * h2
y_pred = ph.setup(h, [drop, lin, ph.lrelu, drop, out, tf.nn.sigmoid])
y_pred_ = ph.setup(h1, [drop, lin, ph.lrelu, drop, out, tf.nn.sigmoid])
y_pred__ = ph.setup(h1,
[drop, lin, ph.lrelu, drop, out, tf.nn.sigmoid])
label_pred = tf.argmax(y_pred, 1)
label = ph.placeholder('label', (None, 2))
loss = tf.reduce_mean((y_pred - label)**2, axis=1)
loss += tf.reduce_mean((y_pred_ - label)**2, axis=1)
loss += tf.reduce_mean((y_pred__ - label)**2, axis=1)
loss_sum = tf.reduce_sum(loss)
loss_mean = tf.reduce_mean(loss)
#
correct = tf.cast(tf.equal(label_pred, tf.argmax(label, 1)), ph.D_TYPE)
correct_pos = correct * label[:, 1]
correct_neg = correct * label[:, 0]
hit_pos = tf.reduce_sum(correct_pos)
hit_neg = tf.reduce_sum(correct_neg)
pred_pos = tf.reduce_sum(label_pred)
pred_neg = tf.reduce_sum(1 - label_pred)
error = tf.reduce_sum(1 - correct)
#
reg = ph.Regularizer()
reg.add_l1(self.get_trainable_variables())
#
optimizer = MaskGrad(tf.train.RMSPropOptimizer(1e-4, 0.8, 0.9))
self._optimizer = optimizer
optimizer.add_mask(shared.cell.wz)
optimizer.add_mask(shared.cell.wr)
optimizer.add_mask(shared.cell.wh)
optimizer.add_mask(shared.cell.uz)
optimizer.add_mask(shared.cell.ur)
optimizer.add_mask(shared.cell.uh)
#
self._add_train_slot(inputs=(seq, label),
outputs={
'Loss': loss_mean,
'Norm': tf.norm(self.specific.cell.uz, 1)
},
updates=(optimizer.minimize(loss_mean +
reg.get_loss(2e-7)),
stat.updates),
givens={drop.keep_prob: 0.5})
self._add_validate_slot(inputs=(seq, label),
outputs={
'Loss': loss_sum,
'hit_pos': hit_pos * 100,
'hit_neg': hit_neg * 100,
'pred_pos': pred_pos * 100,
'pred_neg': pred_neg * 100,
'Error': error * 100,
},
givens={drop.keep_prob: 1.0})
def _build(self):
encoder = vgg.VGG16('encoder')
dense1 = ph.Linear('dense1',
encoder.fc7.output_size,
4096,
w_init=ph.init.TruncatedNormal(0, 1e-3))
dense2 = ph.Linear('dense2',
4096,
self._num_classes,
w_init=ph.init.TruncatedNormal(0, 1e-3))
input_image = ph.placeholder('input_image',
(None, vgg.HEIGHT, vgg.WIDTH, 3),
ph.float)
input_label = ph.placeholder('input_label', (None, ), ph.int)
self._num_gpus -= 1
batch_size = tf.shape(input_image)[0]
num_per_device = tf.cast(tf.ceil(batch_size / self._num_gpus),
tf.int32)
var_list1 = [
*dense1.get_trainable_variables(),
*dense2.get_trainable_variables()
]
var_list2 = self.get_trainable_variables()
y_list = []
loss_list = []
grad_list_list1 = []
grad_list_list2 = []
for i in range(self._num_gpus):
with tf.device(f'/gpu:{i + 1}'):
input_image_i = input_image[i * num_per_device:(i + 1) *
num_per_device]
encoder.setup(input_image_i)
h = encoder['h7'] if i == 0 else encoder[f'h7_{i}']
y = ph.ops.lrelu(dense1.setup(h) + h)
y = tf.nn.softmax(dense2.setup(y))
y_list.append(y)
input_label_i = input_label[i * num_per_device:(i + 1) *
num_per_device]
y_target = tf.one_hot(input_label_i, self._num_classes)
loss = ph.ops.cross_entropy(y_target, y)
loss = tf.reduce_mean(loss)
loss_list.append(loss)
reg1 = ph.reg.L2Regularizer(1e-6)
reg1.setup(var_list1)
grad_list1 = tf.gradients(loss + reg1.get_loss(), var_list1)
grad_list_list1.append(grad_list1)
reg2 = ph.reg.L2Regularizer(1e-6)
reg2.setup(var_list2)
grad_list2 = tf.gradients(loss + reg2.get_loss(), var_list2)
grad_list_list2.append(grad_list2)
y = tf.concat(y_list, axis=0)
loss = tf.reduce_mean(loss_list)
grad_list1 = [
tf.reduce_mean(grads, axis=0) for grads in zip(*grad_list_list1)
]
self.train = ph.Step(inputs=(input_image, input_label),
outputs=loss,
updates=tf.train.RMSPropOptimizer(
1e-5, 0.9, 0.9).apply_gradients(
zip(grad_list1, var_list1)))
grad_list2 = [
tf.reduce_mean(grads, axis=0) for grads in zip(*grad_list_list2)
]
self.fine_tune = ph.Step(inputs=(input_image, input_label),
outputs=loss,
updates=tf.train.RMSPropOptimizer(
1e-6, 0.9, 0.9).apply_gradients(
zip(grad_list2, var_list2)))
label = tf.argmax(y, axis=1)
self.predict = ph.Step(inputs=input_image, outputs=(label, y))
def _build(self):
input_seq0 = self._input_seq0 = ph.placeholder(
'input_seq0', (None, None, self._voc_size))
input_seq1 = self._input_seq1 = ph.placeholder(
'input_seq1', (None, None, self._voc_size))
encoder = self._encoder = seqae.Encoder('encoder',
voc_size=self._voc_size,
emb_size=self._emb_size,
state_size=self._state_size)
emb0 = self._emb0 = encoder.setup(input_seq0)
emb1 = self._emb1 = encoder.setup(input_seq1)
self.predict = ph.Step(inputs=input_seq0, outputs=emb0)
decoder = self._decoder = seqae.Decoder('seq_decoder', self._voc_size,
self._emb_size,
self._state_size,
encoder.emb_layer)
max_len0 = tf.shape(input_seq0)[1]
max_len1 = tf.shape(input_seq1)[1]
rec0 = self._rec0 = decoder.setup(emb0, max_len0)
rec1 = self._rec1 = decoder.setup(emb1, max_len1)
#
# reconstruction loss of the two sequences
loss_rec0 = -ph.ops.log_likelihood(input_seq0, rec0, reduce=False)
loss_rec0 *= tf.sequence_mask(ph.ops.sequence_length(input_seq0),
dtype=ph.dtype)
loss_rec0 = ph.ops.reduce_sum_loss(loss_rec0)
loss_rec0 = tf.reduce_mean(loss_rec0)
self._loss_rec0 = loss_rec0
loss_rec1 = -ph.ops.log_likelihood(input_seq1, rec1, reduce=False)
loss_rec1 *= tf.sequence_mask(ph.ops.sequence_length(input_seq1),
dtype=ph.dtype)
loss_rec1 = ph.ops.reduce_sum_loss(loss_rec1)
loss_rec1 = tf.reduce_mean(loss_rec1)
self._loss_rec1 = loss_rec1
loss_rec = self._loss_rec = loss_rec0 + loss_rec1
#
# semantic loss
# norm0 = tf.norm(emb0, axis=1, keepdims=True)
# norm1 = tf.norm(emb1, axis=1, keepdims=True)
# s = tf.reduce_sum(emb0 * emb1, axis=1) / (norm0 * norm1 + 1e-6)
# s = tf.reduce_mean(s)
#
# loss_semantic = self._loss_semantic = 1.0 - s
loss_semantic = tf.reduce_sum(tf.square(emb0 - emb1), axis=1)
loss_semantic = tf.reduce_mean(loss_semantic)
self._loss_semantic = loss_semantic
#
# train step
loss = self._loss = loss_rec + self._semantic_weight * loss_semantic
reg = ph.reg.Regularizer()
reg.add_l1_l2(self.get_trainable_variables())
update = self._optimizer.minimize(
loss +
reg.get_loss(self._reg_weight) if self._reg_weight > 0 else loss)
self.train = ph.Step(inputs=(input_seq0, input_seq1),
outputs={
'loss': loss,
'loss_rec': loss_rec,
'loss_semantic': loss_semantic,
'rec0': rec0,
'rec1': rec1
},
updates=update)