def test_value_manipulation(self):
val = np.random.random((4, 2))
xth = KTH.variable(val)
xtf = KTF.variable(val)
# get_value
valth = KTH.get_value(xth)
valtf = KTF.get_value(xtf)
assert valtf.shape == valth.shape
assert_allclose(valth, valtf, atol=1e-05)
# set_value
val = np.random.random((4, 2))
KTH.set_value(xth, val)
KTF.set_value(xtf, val)
valth = KTH.get_value(xth)
valtf = KTF.get_value(xtf)
assert valtf.shape == valth.shape
assert_allclose(valth, valtf, atol=1e-05)
# count_params
assert KTH.count_params(xth) == KTF.count_params(xtf)
# print_tensor
check_single_tensor_operation('print_tensor', ())
check_single_tensor_operation('print_tensor', (2, ))
check_single_tensor_operation('print_tensor', (4, 3))
check_single_tensor_operation('print_tensor', (1, 2, 3))
val = np.random.random((3, 2))
xth = KTH.variable(val)
xtf = KTF.variable(val)
assert KTH.get_variable_shape(xth) == KTF.get_variable_shape(xtf)
def on_epoch_end(self, epoch, logs={}):
K.set_value(self.w_cla,
(-self.sigmoid[epoch] + 1) * self.scale_c[epoch])
K.set_value(self.w_dec, (self.sigmoid[epoch]) * self.scale_d[epoch])
self.w_decs.append(K.get_value(self.w_dec))
self.w_clas.append(K.get_value(self.w_cla))
def test_value_manipulation(self):
val = np.random.random((4, 2))
xth = KTH.variable(val)
xtf = KTF.variable(val)
# get_value
valth = KTH.get_value(xth)
valtf = KTF.get_value(xtf)
assert valtf.shape == valth.shape
assert_allclose(valth, valtf, atol=1e-05)
# set_value
val = np.random.random((4, 2))
KTH.set_value(xth, val)
KTF.set_value(xtf, val)
valth = KTH.get_value(xth)
valtf = KTF.get_value(xtf)
assert valtf.shape == valth.shape
assert_allclose(valth, valtf, atol=1e-05)
# count_params
assert KTH.count_params(xth) == KTF.count_params(xtf)
# print_tensor
check_single_tensor_operation('print_tensor', ())
check_single_tensor_operation('print_tensor', (2,))
check_single_tensor_operation('print_tensor', (4, 3))
check_single_tensor_operation('print_tensor', (1, 2, 3))
val = np.random.random((3, 2))
xth = KTH.variable(val)
xtf = KTF.variable(val)
assert KTH.get_variable_shape(xth) == KTF.get_variable_shape(xtf)
def on_epoch_end(self, epoch, logs={}):
if epoch > self.klstart: #grows linearly towards one
new_weight = min(
K.get_value(self.kl_weight) + (1 / self.kl_annealtime), 1.)
print(new_weight)
K.set_value(self.kl_weight, new_weight)
print("Current KL Weight is " + str(K.get_value(self.kl_weight)))
def on_epoch_end(self, epoch, logs={}):
if epoch > self.klstart: #grows linearly towards one
new_weight = min(
K.get_value(self.kl_weight) +
(self.max_kl_weight / self.kl_annealtime), self.max_kl_weight)
#print(new_weight)
K.set_value(self.kl_weight, new_weight)
def reset_states(self, states_value=None):
if len(self.states) == 0:
return
if not self.stateful:
raise AttributeError('Layer must be stateful.')
if not hasattr(self, 'states') or self.states[0] is None:
state_shapes = list(map(K.int_shape, self.model.input[1:]))
self.states = list(map(K.zeros, state_shapes))
if states_value is not None:
if type(states_value) not in (list, tuple):
states_value = [states_value] * len(self.states)
assert len(states_value) == len(
self.states), 'Your RNN has ' + str(len(
self.states)) + ' states, but was provided ' + str(
len(states_value)) + ' state values.'
if 'numpy' not in type(states_value[0]):
states_value = list(map(np.array, states_value))
if states_value[0].shape == tuple():
for state, val in zip(self.states, states_value):
K.set_value(state, K.get_value(state) * 0. + val)
else:
for state, val in zip(self.states, states_value):
K.set_value(state, val)
else:
if self.state_initializer:
for state, init in zip(self.states, self.state_initializer):
if isinstance(init, initializers.Zeros):
K.set_value(state, 0 * K.get_value(state))
else:
K.set_value(state,
K.eval(init(K.get_value(state).shape)))
else:
for state in self.states:
K.set_value(state, 0 * K.get_value(state))
def _build_models(self, hp_lambda=1., lr=0.001):
# Input images from both domains
img = Input(shape=self.img_shape)
self.e = self._build_extracter()
self.c = self._build_classifier()
self.d = self._build_discriminator()
f = self.e(img)
gradInv = self.gradInv = GradientReversal(hp_lambda=hp_lambda)
K.set_value(gradInv.hp_lambda, hp_lambda)
fInv = gradInv(f)
cls = self.c(f)
dom = self.d(fInv)
self.model = Model(inputs=img, outputs=cls, name="model")
self.compile(self.model, lr, name='classifier')
self.classifier = Model(inputs=img, outputs=cls, name="classifier")
self.compile(self.classifier, lr, name='classifier')
self.discriminator = Model(inputs=img, outputs=dom, name="discriminator")
self.compile(self.discriminator, lr * 0.1, name='discrimimator')
def on_epoch_end(self, epoch, logs={}):
tau = np.mod(epoch, int(self.T / self.M)) * 1.0 / int(self.T / self.M)
if tau >= self.R:
new_weight = self.max_kl_weight #capped at 0.0002, because posterior collapose happens!
else:
new_weight = tau * self.max_kl_weight
K.set_value(self.kl_weight, new_weight)
def on_epoch_end(self, epoch, logs={}):
tau = np.mod(epoch, int(self.T / self.M)) * 1.0 / int(self.T / self.M)
if tau >= self.R:
new_weight = 1.0 / 5000 #capped at 0.0002, because posterior collapose happens!
else:
new_weight = tau / 5000
K.set_value(self.kl_weight, new_weight)
print("Current KL Weight is " + str(K.get_value(self.kl_weight)))
def on_batch_begin(self, batch, logs=None):
lr = cosine_decay_with_warmup(global_step=self.global_step,
learning_rate_base=self.learning_rate_base,
total_steps=self.total_steps,
warmup_learning_rate=self.warmup_learning_rate,
warmup_steps=self.warmup_steps,
hold_base_rate_steps=self.hold_base_rate_steps)
K.set_value(self.model.optimizer.lr, lr)
if self.verbose > 0:
print('\nBatch %05d: setting learning '
'rate to %s.' % (self.global_step + 1, lr))
def test_value_manipulation(self):
val = np.random.random((4, 2))
xth = KTH.variable(val)
xtf = KTF.variable(val)
# get_value
valth = KTH.get_value(xth)
valtf = KTF.get_value(xtf)
assert valtf.shape == valth.shape
assert_allclose(valth, valtf, atol=1e-05)
# set_value
val = np.random.random((4, 2))
KTH.set_value(xth, val)
KTF.set_value(xtf, val)
valth = KTH.get_value(xth)
valtf = KTF.get_value(xtf)
assert valtf.shape == valth.shape
assert_allclose(valth, valtf, atol=1e-05)
# count_params
assert KTH.count_params(xth) == KTF.count_params(xtf)
def on_epoch_end(self, epoch, logs={}):
if (self.current <= (self.l_period / 2)):
self.current = self.current + 1
K.set_value(self.w_cla, 0)
K.set_value(self.w_dec, 1)
else:
self.current = self.current + 1
K.set_value(self.w_cla, 1)
K.set_value(self.w_dec, 0)
if (self.current == self.l_period):
self.current = 0
self.w_decs.append(K.get_value(self.w_dec))
self.w_clas.append(K.get_value(self.w_cla))
def test_value_manipulation(self):
val = np.random.random((4, 2))
xth = KTH.variable(val)
xtf = KTF.variable(val)
# get_value
valth = KTH.get_value(xth)
valtf = KTF.get_value(xtf)
assert valtf.shape == valth.shape
assert_allclose(valth, valtf, atol=1e-05)
# set_value
val = np.random.random((4, 2))
KTH.set_value(xth, val)
KTF.set_value(xtf, val)
valth = KTH.get_value(xth)
valtf = KTF.get_value(xtf)
assert valtf.shape == valth.shape
assert_allclose(valth, valtf, atol=1e-05)
# count_params
assert KTH.count_params(xth) == KTF.count_params(xtf)
def train(self, batch_size=16, train_Steps=100, val_Steps=5, nEpochs=100):
gen_S_train = DataGenerator(self.n_classes, self.img_res, self.st_path, batch_size)
gen_S_val = DataGenerator(self.n_classes, self.img_res, self.sv_path, batch_size)
gen_T_train = DataGenerator(self.n_classes, self.img_res, self.tt_path, batch_size)
gen_T_val = DataGenerator(self.n_classes, self.img_res, self.tv_path, batch_size)
gen_S_train.on_epoch_end()
gen_T_train.on_epoch_end()
prev = 0
for epoch in range(nEpochs):
# setting parameters
K.set_value(self.gradInv.hp_lambda, self._hp_scheduler(epoch, nEpochs))
lr = self._lr_scheduler(epoch, nEpochs)
self.compile(self.classifier, lr, name='classifier')
self.compile(self.discriminator, lr*0.1, name='discrimimator')
# train
res_S_train = np.array([0., 0.])
res_d_train = np.asarray([0., 0.])
for batch in tqdm.tqdm(range(train_Steps)):
xSt, ySt = gen_S_train.next()
lSt = self.classifier.train_on_batch(xSt, ySt)
res_S_train += np.asarray(lSt)
xTt, _ = gen_T_train.next()
dSt = np.zeros((batch_size))
dTt = np.ones((batch_size))
ldt = self.discriminator.train_on_batch(np.concatenate((xSt, xTt)), np.concatenate((dSt, dTt)))
res_d_train += np.asarray(ldt)
los_S_train, acc_S_train = res_S_train / train_Steps
los_d_train, acc_d_train = res_d_train / train_Steps
# valid
res_S_val = np.array([0., 0.])
res_T_val = np.asarray([0., 0.])
res_d_val = np.asarray([0., 0.])
for batch in range(val_Steps):
xSv, ySv = gen_S_val.next()
lSv = self.classifier.test_on_batch(xSv, ySv)
res_S_val += np.asarray(lSv)
xTv, yTv = gen_T_val.next()
lTv = self.classifier.test_on_batch(xTv, yTv)
res_T_val += np.asarray(lTv)
dSv = np.zeros((batch_size))
dTv = np.ones((batch_size))
ld = self.discriminator.test_on_batch(np.concatenate((xSv, xTv)), np.concatenate((dSv, dTv)))
res_d_val += np.asarray(ld)
los_S_val, acc_S_val = res_S_val / val_Steps
los_T_val, acc_T_val = res_T_val / val_Steps
los_d_val, acc_d_val = res_d_val / val_Steps
gen_S_val.on_epoch_end()
gen_T_val.on_epoch_end()
val_lr_lambda = K.get_value(self.classifier.optimizer.lr)
val_hp_lambda = K.get_value(self.gradInv.hp_lambda)
print()
print("[Epoch %d, lr=%.1e, lambda=%.1e]" % (epoch, val_lr_lambda, val_hp_lambda))
print("<Train> [Dom loss: %.2f, acc: %3d%%] [Cls(S) loss: %.2f, acc: %3d%%]"
% (los_d_train, acc_d_train*100.,
los_S_train, acc_S_train*100.,))
print("<Val> [Dom loss: %.2f, acc: %3d%%] [Cls(S) loss: %.2f, acc: %3d%%] [Cls(T) loss: %.2f, acc: %3d%%]"
% (los_d_val, acc_d_val*100.,
los_S_val, acc_S_val*100.,
los_T_val, acc_T_val*100.,))
# save weights when Target loss is the minimum
if acc_T_val >= prev:
self.classifier.save_weights(os.path.join(self.output_name, 'dann_acc-{:.2f}_loss-{:.2f}.hdf5'.format(acc_T_val, los_T_val)))
prev = acc_T_val
# draw graph
outlines = []
outlines.append(epoch)
outlines.append(val_lr_lambda)
outlines.append(val_hp_lambda)
outlines.append(los_d_train)
outlines.append(acc_d_train*100.)
outlines.append(los_S_train)
outlines.append(acc_S_train*100.)
outlines.append(los_d_val)
outlines.append(acc_d_val*100.)
outlines.append(los_S_val)
outlines.append(acc_S_val*100.)
outlines.append(los_T_val)
outlines.append(acc_T_val*100.)
self.output_file.write(",".join([str(x) for x in outlines])+"\n")
self.output_file.flush()
d = pd.read_csv(self.output_name+"/progress.csv")
if d.shape[0] == 1:
continue
d = d.interpolate()
p = d.plot(x="epoch", y=["acc_d_v", "acc_c_v_s", "acc_c_v_t"])
fig = p.get_figure()
fig.savefig(self.output_name+"/graph.png")
plt.close()
def on_epoch_end(self, epoch, logs={}):
new_beta = max(K.get_value(self.beta) * self.decay, self.min_beta)
K.set_value(self.beta, new_beta)
print("Current beta is " + str(K.get_value(self.beta)))
agent = DQNAgent(env, max_eps=1, period=0, state_mode=DQNAgent.StateModel.VN_ONLY, gamma=0.8, model=create_model_10(env)) hist = agent.train() hist # In[13]: plt.plot([x['reward'] for x in hist[0]]) # In[16]: K.set_value(agent.model.optimizer.lr, 0.001) hist = agent.train() # In[17]: plt.plot([x['reward'] for x in hist[0]]) # In[20]: K.set_value(agent.model.optimizer.lr, 0.0001) hist = agent.train()
if load_checkpoint is not None:
fm.loadModel(model, load_checkpoint)
last_checkpoint = load_checkpoint
model.reset_states()
model.evaluate(XX_validation[:preamble],
YY_validation[:preamble],
batch_size=nbatch,
verbose=0)
current_loss = model.evaluate(XX_validation[preamble:],
YY_validation[preamble:],
batch_size=nbatch,
verbose=0)
print "Loaded weights from %s: Learning rate = %.8f, Validation loss = %08.6f" % (
load_checkpoint, learning_rate, current_loss)
KTF.set_value(model.optimizer.lr, learning_rate)
try:
for iii in range(0, 100000):
XXs, YYs = generateXYChunk(X, nbatch, epoch_timesteps, maxlen, length)
model.reset_states()
model.evaluate(XXs[:preamble],
YYs[:preamble],
batch_size=nbatch,
verbose=0)
model.fit(XXs[preamble:],
YYs[preamble:],
batch_size=nbatch,