def pretrain_phase2(model: ADEC,
seeds,
groups,
label,
batch_size,
epochs=1000,
save_interval=200,
save_path='./images',
early_stopping=False):
n_epochs = tqdm.tqdm_notebook(range(epochs))
total_batches = seeds.shape[0] // batch_size
EARLY_STOPPING_THRESHOLD = 1e-4
PATIENCE = 20
last_ae_loss = 10e10
p_count = 0
groups_label = get_group_label(groups, label)
if not os.path.exists(save_path):
os.makedirs(save_path)
epochs_for_disc = epochs // 3
for epoch in n_epochs:
offset = 0
losses = []
random_idx = np.random.randint(0, seeds.shape[0], seeds.shape[0])
seeds_shuffle = seeds[random_idx, :]
for batch_iter in range(total_batches):
# Randomly choose each half batch
imgs = seeds_shuffle[offset:offset + batch_size, ::] if (
batch_iter <
(total_batches - 1)) else seeds_shuffle[:batch_size, :]
offset += batch_size
loss = model.pretrain_on_batch_phase2(imgs, None)
losses.append(loss)
avg_loss = avg_losses(losses)
wandb.log({'pretrain_phase2_losses': avg_loss})
if epoch % save_interval == 0 or (epoch == epochs - 1):
# Save the visualization of latent space
latent = model.encoder.predict(seeds)
latent_space_img = visualize_latent_space(
latent,
groups_label,
10,
is_save=True,
save_path=f'{save_path}/latent_{epoch}.png')
wandb.log({
'latent_space':
[wandb.Image(latent_space_img, caption="Latent space")]
})
if early_stopping:
if last_ae_loss - avg_loss[
'res_ae_loss'] < EARLY_STOPPING_THRESHOLD:
p_count += 1
if p_count == PATIENCE:
print(f'No improvement after {PATIENCE} epochs. Stop!')
break # Stop training
def train(model: ACAI,
x_train,
y_train,
x_test,
batch_size,
epochs=1000,
save_interval=200,
save_path='./images'):
n_epochs = tqdm.tqdm_notebook(range(epochs))
total_batches = x_train.shape[0] // batch_size
if not os.path.exists(save_path):
os.makedirs(save_path)
for epoch in n_epochs:
offset = 0
losses = []
random_idx = np.random.randint(0, x_train.shape[0], x_train.shape[0])
for batch_iter in range(1):
# Randomly choose each half batch
imgs = x_train[offset:offset + batch_size, ::] if (
batch_iter < (total_batches - 1)) else x_train[offset:, ::]
offset += batch_size
loss = train_on_batch(imgs, None, model)
losses.append(loss)
avg_loss = avg_losses(losses)
# wandb.log({'losses': avg_loss})
if epoch % save_interval == 0 or (epoch == epochs - 1):
sampled_imgs = model.autoencoder(x_test[:100])
res_img = make_image_grid(sampled_imgs.numpy(), (28, 28),
str(epoch), save_path)
latent = model.encoder(x_train, training=False).numpy()
latent_space_img = visualize_latent_space(
latent,
y_train,
10,
is_save=True,
save_path=f'./latent_space/{epoch}')
obs = tf.convert_to_tensor(obs, dtype=tf.float32)
rewards = tf.convert_to_tensor(rewards, dtype=tf.float32)
rewards = discount_rewards(rewards)
return obs, rewards
def train():
obs, rewards = interaction_process()
with tf.GradientTape() as tape:
tf.transpose(tf.math.log(model(obs)[1])) * rewards
loss = -tf.reduce_sum()
gradient = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradient, model.trainable_variables))
return loss.numpy(), rewards
if __name__ == '__main__':
Epochs = 10000
losses = []
for epoch in range(Epochs):
loss, rewards = train()
losses.append(loss)
print('epochs:{}, loss:{}'.format(epoch, loss))
if epoch % 1000 == 0:
plot_df = df[price_col]
portfolio = [10000]
portfolio.extend(rewards)
portfolio.append(np.nan)
plot_df.loc[:, 'rewards'] = portfolio
plot_df.to_csv('./data_for_analysis/%s_df.csv' % epoch)
model.save('./model/policy_gradient.h5')
def cluster(model: ADEC,
seeds,
groups,
label,
batch_size,
epochs=1000,
save_interval=200,
save_path='./images'):
n_epochs = tqdm.tqdm_notebook(range(epochs))
total_batches = seeds.shape[0] // batch_size
if not os.path.exists(save_path):
os.makedirs(save_path)
groups_label = get_group_label(groups, label)
# Using kmeans result to initialize clusters for model
latent = adec.encoder.predict(seeds)
kmeans = KMeans(n_clusters=model.n_clusters, n_init=100)
init_cluster_pred = kmeans.fit_predict(latent)
_, _, init_f1 = genome_acc(groups, init_cluster_pred, label,
model.n_clusters)
print('Initialized performance: ', init_f1)
model.cluster.get_layer(name='clustering').set_weights(
[kmeans.cluster_centers_])
# Check model cluster performance
non_wh_cluster_res = model.cluster.predict(seeds).argmax(1)
_, _, init_f1_1 = genome_acc(groups, non_wh_cluster_res, label,
model.n_clusters)
print('Model cluster performance: ', init_f1_1)
stop = False
last_cluster_pred = np.copy(non_wh_cluster_res)
for epoch in n_epochs:
offset = 0
losses = []
if epoch % save_interval == 0 or (epoch == epochs - 1):
# Save the visualization of latent space
latent = model.encoder.predict(seeds)
latent_space_img = visualize_latent_space(
latent,
groups_label,
model.n_clusters,
is_save=True,
save_path=f'{save_path}/latent_{epoch}.png')
# Log the clustering performance
cluster_res = model.cluster.predict(seeds)
y_pred = cluster_res.argmax(1)
_, _, f1 = genome_acc(groups, y_pred, label, model.n_clusters)
try:
wandb.log({
'latent_space':
[wandb.Image(latent_space_img, caption="Latent space")],
'cluster_f1':
f1
})
except:
print('cluster_f1: ', f1)
delta_label = np.sum(y_pred != last_cluster_pred).astype(
np.float32) / y_pred.shape[0]
if epoch > 0 and delta_label < model.tol:
stop = False
break
last_cluster_pred = np.copy(cluster_res)
# Update target distribution
targ_dist = model.target_distribution(last_cluster_pred)
is_alternate = False
for batch_iter in range(total_batches):
# Randomly choose each half batch
imgs = seeds[offset:offset + batch_size, :] if (
batch_iter < (total_batches - 1)) else seeds[:batch_size, :]
y_cluster = targ_dist[offset:offset + batch_size, :] if (
batch_iter <
(total_batches - 1)) else targ_dist[:batch_size, :]
offset += batch_size
if batch_iter < int(2 * total_batches / 3) and total_batches >= 3:
is_alternate = True
else:
is_alternate = False
loss = model.train_on_batch(imgs, y_cluster, is_alternate)
losses.append(loss)
avg_loss = avg_losses(losses)
try:
wandb.log({'clustering_losses': avg_loss})
except:
pass
if stop:
# Reach stop condition, stop training
break
def train(model: AdversarialAutoencoder,
x_train,
y_train,
batch_size,
epochs=1000,
save_interval=200,
save_path='./images'):
# latents = 5 * np.random.normal(size=(100, model.latent_dim))
latents = 5 * np.random.uniform(-1, 1, size=(100, model.latent_dim))
n_epochs = tqdm.tqdm_notebook(range(epochs))
half_batch = int(batch_size / 2)
total_batches = x_train.shape[0] // batch_size
if not os.path.exists(save_path):
os.makedirs(save_path)
for epoch in n_epochs:
losses = []
offset = 0
for batch_iter in range(1):
# Randomly choose each half batch
imgs = x_train[offset:offset + batch_size, ::] if (
batch_iter < (total_batches - 1)) else x_train[offset:, ::]
offset += batch_size
# Randomly choose each half batch
idx = np.random.randint(0, x_train.shape[0], half_batch)
imgs = x_train[idx]
# Train discriminator
## Get fake and real latent feature
latent_fake = model.encoder.predict(imgs)
latent_real = 5 * np.random.normal(size=(half_batch,
model.latent_dim))
d_real = np.ones((half_batch, 1))
d_fake = np.zeros((half_batch, 1))
## train
d_loss_real = model.discriminator.train_on_batch(
latent_real, d_real)
d_loss_fake = model.discriminator.train_on_batch(
latent_fake, d_fake)
d_loss = d_loss_real + d_loss_fake
idx = np.random.randint(0, x_train.shape[0], batch_size)
imgs = x_train[idx]
# Train autoencoder
ae_loss = model.autoencoder.train_on_batch(imgs, imgs)
# Train generator
g_real = np.ones((batch_size, 1))
g_loss = model.generator.train_on_batch(imgs, g_real)
loss = {'ae_loss': ae_loss, 'g_loss': g_loss, 'd_loss': d_loss}
losses.append(loss)
avg_loss = avg_losses(losses)
# wandb.log({'losses': avg_loss})
if epoch % save_interval == 0 or (epoch == epochs - 1):
sampled_imgs = model.decoder(latents, training=False)
res_img = make_image_grid(sampled_imgs.numpy(), (28, 28),
str(epoch), save_path)
latent = model.encoder.predict(x_train)
latent_space_img = visualize_latent_space(
latent,
y_train,
10,
is_save=True,
save_path=f'./latent_space/{epoch}.png')
def run():
# learning rate
lr = 1e-2
accs, losses = [], []
# 784 => 512
w1, b1 = tf.Variable(tf.random.normal([784, 256],
stddev=0.1)), tf.Variable(
tf.zeros([256]))
# 512 => 256
w2, b2 = tf.Variable(tf.random.normal([256, 128],
stddev=0.1)), tf.Variable(
tf.zeros([128]))
# 256 => 10
w3, b3 = tf.Variable(tf.random.normal([128, 10], stddev=0.1)), tf.Variable(
tf.zeros([10]))
for step, (x, y) in enumerate(train_db):
# [b, 28, 28] => [b, 784]
x = tf.reshape(x, (-1, 784))
with tf.GradientTape() as tape:
# layer1.
h1 = x @ w1 + b1
h1 = tf.nn.relu(h1)
# layer2
h2 = h1 @ w2 + b2
h2 = tf.nn.relu(h2)
# output
out = h2 @ w3 + b3
# out = tf.nn.relu(out)
# compute loss
# [b, 10] - [b, 10]
loss = tf.square(y - out)
# [b, 10] => scalar
loss = tf.reduce_mean(loss)
grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])
for p, g in zip([w1, b1, w2, b2, w3, b3], grads):
p.assign_sub(lr * g)
# print
if step % 100 == 0:
print(step, 'loss:', float(loss))
losses.append(float(loss))
if step % 100 == 0:
# evaluate/test
total, total_correct = 0., 0
for x, y in test_db:
# layer1.
h1 = x @ w1 + b1
h1 = tf.nn.relu(h1)
# layer2
h2 = h1 @ w2 + b2
h2 = tf.nn.relu(h2)
# output
out = h2 @ w3 + b3
# [b, 10] => [b]
pred = tf.argmax(out, axis=1)
# convert one_hot y to number y
y = tf.argmax(y, axis=1)
# bool type
correct = tf.equal(pred, y)
# bool tensor => int tensor => numpy
total_correct += tf.reduce_sum(tf.cast(
correct, dtype=tf.int32)).numpy()
total += x.shape[0]
print(step, 'Evaluate Acc:', total_correct / total)
accs.append(total_correct / total)
plt.figure()
x = [i * 80 for i in range(len(losses))]
plt.plot(x, losses, color='C0', marker='s', label='训练')
plt.ylabel('MSE')
plt.xlabel('Step')
plt.legend()
plt.savefig('train.svg')
plt.figure()
plt.plot(x, accs, color='C1', marker='s', label='测试')
plt.ylabel('准确率')
plt.xlabel('Step')
plt.legend()
plt.savefig('test.svg')