def eval(configs):
"""
evaluate the autoencoder, including generation of tsv files, mse of reconstruction and label accuracy.
Args:
configs (dict): configurations of the autoencoder.
Returns:
None
"""
# load configs and data
batch_size = configs["batch_size"]
dataset_name = configs["dataset_name"]
filter = configs["filter"]
tsv_gen = configs["tsv_gen"]
encode_adv = configs["encode_adv"]
subset = "test"
label_name = configs["label_name"]
include_meta = configs["include_meta"]
# dont shuffle since its already shuffled in datareader
if include_meta:
test, meta = load_dataset(dataset_name,
sets=[subset],
include_meta=include_meta,
label_name=label_name,
batch_size=batch_size,
shuffle=False)[0]
else:
test = load_dataset(dataset_name,
sets=[subset],
include_meta=include_meta,
label_name=label_name,
batch_size=batch_size,
shuffle=False)[0]
draw_scatter = configs["draw_scatter"]
latent_dim = configs["latent_dim"]
use_clf_label = configs["use_clf_label"]
with open("../data/{}/metadata.txt".format(dataset_name)) as file:
metadata = json.load(file)
num_classes = metadata["num_classes"]
field_names = metadata["field_names"][:-1]
input_dim = len(field_names)
datamin = np.array(metadata["col_min"][:-1])
datamax = np.array(metadata["col_max"][:-1])
scaler, unscaler = min_max_scaler_gen(datamin, datamax)
packed_test_data = test.map(
PackNumericFeatures(field_names, num_classes, scaler=None))
# load models
custom_objects = {'WcLayer': WcLayer}
prefix = "{}_{}_{}".format(dataset_name, latent_dim, use_clf_label)
aae = tf.keras.models.load_model("../models/aae/{}_aae.h5".format(prefix),
custom_objects=custom_objects)
encoder = tf.keras.models.load_model(
"../models/aae/{}_encoder.h5".format(prefix),
custom_objects=custom_objects)
decoder = tf.keras.models.load_model(
"../models/aae/{}_decoder.h5".format(prefix),
custom_objects=custom_objects)
latent_discriminator = tf.keras.models.load_model(
"../models/aae/{}_lat_disc.h5".format(prefix))
cat_discriminator = tf.keras.models.load_model(
"../models/aae/{}_cat_disc.h5".format(prefix))
classification_model = tf.keras.models.load_model("../models/{}_{}".format(
configs["clf_type"], dataset_name))
steps = metadata["num_{}".format(subset)] // batch_size
# get wc layer weights as clusterheads
wc_layer = aae.get_layer("wc_layer")
wc_weights = wc_layer.weights[0].numpy()
print("cluster_heads:", wc_weights)
# setup plt figures if draw_scatter
if draw_scatter:
fig, ax = plt.subplots(2, 1, figsize=(10, 20))
ax[0].set_title("style")
ax[1].set_title("representations")
if tsv_gen:
# set up file handler for tsv files
style_file = open("../experiment/aae_vis/{}_style.tsv".format(prefix),
"w")
label_file = open("../experiment/aae_vis/{}_labels.tsv".format(prefix),
"w")
representation_file = open(
"../experiment/aae_vis/{}_representation.tsv".format(prefix), "w")
# read attack map for labelling
attack_map = read_maps("../data/{}/maps/{}.csv".format(
dataset_name, label_name))
# vectorize attack map with prefixes. prefix used to distinguish adversarial samples
attack_mapper = np.vectorize(lambda x, pref: pref + attack_map[x])
# write clusterheads to style and representation file
np.savetxt(style_file, wc_weights, delimiter="\t")
np.savetxt(representation_file, wc_weights, delimiter="\t")
# write header for meta file
meta_col = metadata["meta_col"]
header = [['true_label', 'aae_pred_label', "clf_label"] + meta_col +
["dim1", "dim2", "dim3"]]
np.savetxt(label_file, header, delimiter="\t", fmt="%s")
# write meta file for cluster heads, labels are prefixed by ch_ and meta_cols are set to 0
ch_labels = np.core.defchararray.add("ch_", attack_map)
ch_meta = np.stack(
(ch_labels, ch_labels, ch_labels,
*list(np.zeros(ch_labels.shape) for i in range(len(meta_col))),
wc_weights[:, 0], wc_weights[:, 1], wc_weights[:, 2]),
axis=1)
np.savetxt(label_file, ch_meta, delimiter="\t", fmt="%s")
# label accuracy
aae_true_acc = tf.keras.metrics.CategoricalAccuracy()
clf_aae_acc = tf.keras.metrics.CategoricalAccuracy()
clf_true_acc = tf.keras.metrics.CategoricalAccuracy()
# mse
recon_mse = tf.keras.metrics.MeanSquaredError()
label_mse = tf.keras.metrics.MeanSquaredError()
normalized_mse = tf.keras.metrics.MeanSquaredError()
if include_meta:
data = tf.data.Dataset.zip((packed_test_data, meta))
else:
data = packed_test_data
for entry in data.take(steps):
if include_meta:
a, b = entry
features = a[0]
labels = a[1]
else:
features = entry[0]
labels = entry[1]
input_feature = scaler(features.numpy())
style, representation, pred_label = encode(encoder, wc_layer,
input_feature)
decoded = decoder(representation)
reconstruction = unscaler(decoded.numpy())
clf_label = classification_model(input_feature)
label_mse.update_state(labels, pred_label)
recon_mse.update_state(features.numpy(), reconstruction)
normalized_mse.update_state(decoded, input_feature)
aae_true_acc.update_state(labels, pred_label)
clf_aae_acc.update_state(clf_label, pred_label)
clf_true_acc.update_state(clf_label, labels)
# encoded = aae.encoder(features['numeric'].numpy())
# output_wrt_dim(vae., features['numeric'].numpy()[0], field_names)
# forward_derviative(vae.decoder, encoded[0], ["dim{}".format(i) for i in range(latent_dim)])
# eval_with_different_label(aae, features["numeric"].numpy(), labels)
if draw_scatter:
# draw scatter of each batch
ax[0].scatter(style.numpy()[:, 0],
style.numpy()[:, 1],
c=labels,
s=1)
ax[1].scatter(representation.numpy()[:, 0],
representation.numpy()[:, 1],
c=labels,
s=1)
if tsv_gen:
# generate tsv file for each batch
np.savetxt(style_file, style, delimiter="\t")
np.savetxt(representation_file, representation, delimiter="\t")
if include_meta:
label_arr = np.stack(
(attack_mapper(np.argmax(labels, axis=1), ""),
attack_mapper(np.argmax(pred_label, axis=1), ""),
attack_mapper(np.argmax(clf_label, axis=1), ""),
*list(b[x].numpy()
for x in b.keys()), representation[:, 0],
representation[:, 1], representation[:, 2]),
axis=1)
else:
label_arr = np.stack(
(attack_mapper(np.argmax(labels, axis=1), ""),
attack_mapper(np.argmax(pred_label, axis=1), ""),
attack_mapper(np.argmax(clf_label, axis=1),
""), representation[:, 0],
representation[:, 1], representation[:, 2]),
axis=1)
np.savetxt(label_file, label_arr, delimiter="\t", fmt="%s")
print("average mse:", recon_mse.result().numpy())
print("average scaled mse:", normalized_mse.result().numpy())
print("average label mse: ", label_mse.result().numpy())
print("average real vs pred acc:", aae_true_acc.result().numpy())
print("average clf vs pred acc:", clf_aae_acc.result().numpy())
print("average clf vs real acc:", clf_true_acc.result().numpy())
# draw adversarial samples
if encode_adv:
adv_path = "../experiment/adv_data/{}_{}.csv".format(
dataset_name, subset)
# use adv label as label, this is the same as clf label
data = tf.data.experimental.make_csv_dataset(
adv_path,
batch_size=1000,
select_columns=field_names + ["Adv Label"],
label_name="Adv Label")
packed_data = data.map(PackNumericFeatures(field_names, num_classes))
for features, labels in packed_data.take(10):
input_feature = scaler(features.numpy())
_, representation, pred_label = encode(encoder, wc_layer,
input_feature)
clf_label = classification_model(input_feature)
pred_label = np.argmax(pred_label.numpy(), axis=1)
labels = np.argmax(labels.numpy(), axis=1)
clf_label = np.argmax(clf_label.numpy(), axis=1)
np.savetxt(representation_file, representation, delimiter="\t")
# meta for this file will only contain the labels
np.savetxt(label_file,
np.stack((attack_mapper(
labels, "adv_"), attack_mapper(
pred_label, ""), attack_mapper(clf_label, "")),
axis=1),
delimiter="\t",
fmt="%s")
#
# data, meta = load_dataset(
# dataset_name, sets=[subset], include_meta=True,
# label_name="category", batch_size=batch_size, shuffle=False,filter=filter)[0]
#
# packed_data = data.map(PackNumericFeatures(
# field_names, num_classes, scaler=None))
# for a, b in tf.data.Dataset.zip((packed_data, meta)).take(2):
# features = a[0]
# labels = a[1]
# input_feature = scaler(features.numpy())
#
# style, representation, pred_label = encode_with_different_label(
# encoder, wc_layer, input_feature,np.repeat(np.array([[0.,0.,1.]]),batch_size, axis=0), decoder)
# clf_label=classification_model(input_feature)
#
# pred_label = np.argmax(pred_label.numpy(), axis=1)
# labels = np.argmax(labels.numpy(), axis=1)
# clf_label = np.argmax(clf_label.numpy(), axis=1)
#
# np.savetxt(representation_file, representation, delimiter="\t")
# # meta for this file will only contain the labels
# np.savetxt(label_file, np.stack((attack_mapper(labels, "aae_adv_"), attack_mapper(
# pred_label, ""),attack_mapper(clf_label, "")), axis=1), delimiter="\t", fmt="%s")
if draw_scatter:
# add cluster_head
ax[0].scatter(wc_weights[:, 0],
wc_weights[:, 1],
c=[x for x in range(num_classes)])
ax[1].scatter(wc_weights[:, 0],
wc_weights[:, 1],
c=[x for x in range(num_classes)])
# add legend and save figure
legend1 = ax[0].legend(*ax[0].collections[0].legend_elements(),
loc="lower left",
title="Classes")
legend12 = ax[0].legend(*ax[0].collections[-1].legend_elements(),
loc="upper left",
title="Cluster Heads")
legend2 = ax[1].legend(*ax[1].collections[0].legend_elements(),
loc="lower left",
title="Classes")
legend22 = ax[1].legend(*ax[1].collections[-1].legend_elements(),
loc="upper left",
title="Cluster Heads")
ax[0].add_artist(legend1)
ax[0].add_artist(legend12)
ax[1].add_artist(legend2)
ax[1].add_artist(legend22)
plt.tight_layout()
plt.savefig('../experiment/aae_vis/{}_scatter.png'.format(prefix))
if tsv_gen:
# clean up file handles
style_file.close()
label_file.close()
representation_file.close()
def encode_features(configs):
"""
encode the feature set to latent space
Args:
configs (dict): configurations of the autoencoder.
Returns:
None
"""
# load configs and data
batch_size = configs["batch_size"]
dataset_name = configs["dataset_name"]
filter = configs["filter"]
tsv_gen = configs["tsv_gen"]
encode_adv = configs["encode_adv"]
subset = "test"
label_name = configs["label_name"]
include_meta = configs["include_meta"]
feature_path = configs["feature_path"]
meta_file = configs["meta_file"]
# load feature csv
feature_set = tf.data.experimental.make_csv_dataset(feature_path,
batch_size,
shuffle=False)
meta_data = open(meta_file, "r")
meta_data.readline()
draw_scatter = configs["draw_scatter"]
latent_dim = configs["latent_dim"]
use_clf_label = configs["use_clf_label"]
with open("../data/{}/metadata.txt".format(dataset_name)) as file:
metadata = json.load(file)
datamin = np.array(metadata["col_min"][:-1])
datamax = np.array(metadata["col_max"][:-1])
field_names = metadata["field_names"][:-1]
feature_set = feature_set.map(PackNumericFeatures(field_names))
scaler, unscaler = min_max_scaler_gen(datamin, datamax)
# load models
custom_objects = {'WcLayer': WcLayer}
prefix = "{}_{}_{}".format(dataset_name, latent_dim, use_clf_label)
aae = tf.keras.models.load_model("../models/aae/{}_aae.h5".format(prefix),
custom_objects=custom_objects)
encoder = tf.keras.models.load_model(
"../models/aae/{}_encoder.h5".format(prefix),
custom_objects=custom_objects)
decoder = tf.keras.models.load_model(
"../models/aae/{}_decoder.h5".format(prefix),
custom_objects=custom_objects)
latent_discriminator = tf.keras.models.load_model(
"../models/aae/{}_lat_disc.h5".format(prefix))
cat_discriminator = tf.keras.models.load_model(
"../models/aae/{}_cat_disc.h5".format(prefix))
classification_model = tf.keras.models.load_model("../models/{}_{}".format(
configs["clf_type"], dataset_name))
steps = configs["num_pkt"] // batch_size
# get wc layer weights as clusterheads
wc_layer = aae.get_layer("wc_layer")
wc_weights = wc_layer.weights[0].numpy()
prefix = "{}_{}".format(dataset_name, feature_path.split("/")[-1])
label_file = open("../experiment/aae_vis/{}_labels.tsv".format(prefix),
"w")
representation_file = open(
"../experiment/aae_vis/{}_representation.tsv".format(prefix), "w")
# read attack map for labelling
attack_map = read_maps("../data/{}/maps/{}.csv".format(
dataset_name, label_name))
# vectorize attack map with prefixes. prefix used to distinguish adversarial samples
attack_mapper = np.vectorize(lambda x, pref: pref + attack_map[x])
craft_bypass_cnt = 0
total_craft = 0
mal_bypass_cnt = 0
total_mal = 0
header = [['aae_pred_label', 'index', 'comment'] +
["dim1", "dim2", "dim3"]]
np.savetxt(label_file, header, delimiter="\t", fmt="%s")
batch_index = 0
for feature in tqdm(feature_set.take(steps)):
input_feature = scaler(feature.numpy())
style, representation, pred_label = encode(encoder, wc_layer,
input_feature)
comments_arr = []
for i in range(batch_size):
comments = meta_data.readline().rstrip().split(",")
comments_arr.append(comments)
if comments[1] == "malicious":
if np.argmax(pred_label[i]) == 1:
mal_bypass_cnt += 1
total_mal += 1
if comments[1] == "craft":
if np.argmax(pred_label[i]) == 1:
craft_bypass_cnt += 1
total_craft += 1
np.savetxt(representation_file, representation, delimiter="\t")
label_arr = np.hstack(
(np.expand_dims(attack_mapper(np.argmax(pred_label, axis=1), ""),
axis=1), np.array(comments_arr), representation))
np.savetxt(label_file, label_arr, delimiter="\t", fmt="%s")
batch_index += 1
print("malicious bypass rate", mal_bypass_cnt / total_mal)
print("total malcious packets", total_mal)
print("craft bypass rate", craft_bypass_cnt / total_craft)
print("total craft packets", total_craft)
def train_aae(configs):
batch_size = configs["batch_size"]
dataset_name = configs["dataset_name"]
filter = configs["filter"]
label_name = configs["label_name"]
train, val = load_dataset(dataset_name,
sets=["train", "val"],
shuffle=False,
label_name=label_name,
batch_size=batch_size,
filter=filter)
epochs = configs["epochs"]
latent_dim = configs["latent_dim"]
intermediate_dim = configs["intermediate_dim"]
use_clf_label = configs["use_clf_label"]
weight = configs["reconstruction_weight"]
loss_weights = [
weight, (1 - weight) / 3, (1 - weight) / 3, (1 - weight) / 3
]
distance_thresh = configs["distance_thresh"]
classification_model = tf.keras.models.load_model("../models/{}_{}".format(
configs["clf_type"], dataset_name))
# if not hyperparameter tuning, set up tensorboard
logdir = "tensorboard_logs/aae/" + datetime.now().strftime("%Y%m%d-%H%M%S")
train_summary_writer = tf.summary.create_file_writer(logdir)
with open("../data/{}/metadata.txt".format(dataset_name)) as file:
metadata = json.load(file)
num_classes = metadata["num_classes"]
field_names = metadata["field_names"][:-1]
input_dim = len(field_names)
datamin = np.array(metadata["col_min"][:-1])
datamax = np.array(metadata["col_max"][:-1])
scaler, unscaler = min_max_scaler_gen(datamin, datamax)
data_range = datamax - datamin
#
packed_train_data = train.map(
PackNumericFeatures(field_names, num_classes, scaler=scaler))
packed_val_data = val.map(
PackNumericFeatures(field_names, num_classes, scaler=scaler))
# Create a MirroredStrategy.
# strategy = tf.distribute.MirroredStrategy()
# print('Number of devices: {}'.format(strategy.num_replicas_in_sync))
#
# # Open a strategy scope.
# with strategy.scope():
# oop version does not provide a good graph trace so using functional instead
aae, encoder, decoder, latent_discriminator, cat_discriminator = build_aae_dim_reduce(
input_dim, intermediate_dim, latent_dim, num_classes, distance_thresh,
None, None, loss_weights)
# wmse=weighted_mse(data_range)
aae.compile(loss=[
tf.keras.losses.MeanSquaredError(),
tf.keras.losses.BinaryCrossentropy(),
tf.keras.losses.BinaryCrossentropy(),
tf.keras.losses.MeanSquaredError()
],
loss_weights=loss_weights,
optimizer='adam',
metrics=[[MeanSquaredError(name="latent_mse")],
[BinaryAccuracy(name="latent_acc")],
[BinaryAccuracy(name="label_acc")],
[MeanSquaredError(name="label_mse")]])
valid = np.ones((batch_size, 1))
invalid = np.zeros((batch_size, 1))
step = 0
pbar = tqdm(range(epochs), desc="epoch")
for epoch in pbar:
steps = metadata["num_train"] // batch_size
step_pbar = tqdm(total=steps, desc="steps", leave=False, position=1)
for feature, label in packed_train_data.take(steps):
fake_latent, fake_cat = encoder(feature)
# train latent discriminator
latent_discriminator.trainable = True
real_latent = sample_prior(batch_size,
distro="normal",
latent_dim=latent_dim)
noise_real = np.random.normal(0,
0.5,
size=(batch_size, latent_dim))
d_loss_real = latent_discriminator.train_on_batch(
real_latent + noise_real, valid)
d_loss_fake = latent_discriminator.train_on_batch(
fake_latent, invalid)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
latent_discriminator.trainable = False
# train cat discriminator
cat_discriminator.trainable = True
if use_clf_label:
real_cat = classification_model(feature)
real_cat = np.argmax(real_cat, axis=-1)
real_cat = np.eye(num_classes)[real_cat]
else:
real_cat = label
cat_loss_real = cat_discriminator.train_on_batch(real_cat, valid)
cat_loss_fake = cat_discriminator.train_on_batch(fake_cat, invalid)
cat_loss = 0.5 * np.add(cat_loss_real, cat_loss_fake)
cat_discriminator.trainable = False
# train generator
g_loss = aae.train_on_batch(feature,
[feature, valid, valid, real_cat])
# record losses if not tuning
with train_summary_writer.as_default():
tf.summary.scalar('latent loss', d_loss[0], step=step)
tf.summary.scalar('latent acc', d_loss[1], step=step)
tf.summary.scalar('cat loss', cat_loss[0], step=step)
tf.summary.scalar('cat acc', cat_loss[1], step=step)
for i in range(len(aae.metrics_names)):
tf.summary.scalar(aae.metrics_names[i],
g_loss[i],
step=step)
step += 1
step_pbar.update(1)
# record distribution after epoch
style, label = encoder(feature)
with train_summary_writer.as_default():
tf.summary.histogram('cat_disc_out',
cat_discriminator(label),
step=step)
tf.summary.histogram('lat_disc_out',
latent_discriminator(style),
step=step)
tf.summary.histogram('style', style, step=step)
tf.summary.histogram('label', label, step=step)
tf.summary.histogram('prior style',
real_latent + noise_real,
step=step)
tf.summary.histogram('prior label', real_cat, step=step)
step_pbar.reset()
postfix = {
"latent_acc": 100 * d_loss[1],
"cat_acc": 100 * cat_loss[1],
"mse": g_loss[5]
}
pbar.set_postfix(postfix)
# trace aae with dummy value and save model
feature, label = list(packed_val_data.take(1).as_numpy_iterator())[0]
feature = np.zeros((1, input_dim))
label = np.zeros((num_classes))
latent = np.zeros((1, latent_dim))
# trace aae
with train_summary_writer.as_default():
tf.summary.trace_on(graph=True, profiler=True)
tracer(aae, feature)
tf.summary.trace_export(name="aae", step=0, profiler_outdir=logdir)
# tf.keras.models.save_model(aae, "../models/aae/test")
prefix = "{}_{}_{}".format(dataset_name, latent_dim, use_clf_label)
if not os.path.isdir("../models/aae"):
os.makedirs("../models/aae")
aae.save("../models/aae/{}_aae.h5".format(prefix))
encoder.save("../models/aae/{}_encoder.h5".format(prefix))
decoder.save("../models/aae/{}_decoder.h5".format(prefix))
latent_discriminator.save("../models/aae/{}_lat_disc.h5".format(prefix))
cat_discriminator.save("../models/aae/{}_cat_disc.h5".format(prefix))
def eval(configs):
batch_size = configs["batch_size"]
dataset_name = configs["dataset_name"]
test = load_dataset(dataset_name,
sets=configs["data_sets"],
label_name="category",
batch_size=batch_size)[0]
supervised = configs["supervised"]
with open("../data/{}/metadata.txt".format(dataset_name)) as file:
metadata = json.load(file)
num_classes = metadata["num_classes"]
field_names = metadata["field_names"][:-1]
input_dim = len(field_names)
datamin = np.array(metadata["col_min"][:-1])
datamax = np.array(metadata["col_max"][:-1])
scaler, unscaler = min_max_scaler_gen(datamin, datamax)
# original, jsma, fgsm=main()
packed_test_data = test.map(
PackNumericFeatures(field_names, num_classes, scaler=scaler))
aae = tf.keras.models.load_model("../models/aae/aae.h5")
encoder = tf.keras.models.load_model("../models/aae/encoder.h5")
decoder = tf.keras.models.load_model("../models/aae/decoder.h5")
loss_func = tf.keras.losses.MeanSquaredError()
steps = metadata["num_test"] // batch_size
print("evaluating reconstruction error with mean squared error")
f = plt.figure(figsize=(15, 10))
# visualize stuff
latent_file = open("../experiment/aae_vis/{}_points.tsv".format(aae.name),
"w")
latent_label = open("../experiment/aae_vis/{}_labels.tsv".format(aae.name),
"w")
pred_label_file = open(
"../experiment/aae_vis/{}_pred_labels.tsv".format(aae.name), "w")
total_mse = 0
correct_label = 0
for features, labels in packed_test_data.take(steps):
encoded, pred_label = encoder(features['numeric'].numpy())
decoded = decoder([encoded, pred_label])
labels = np.argmax(labels, axis=1)
pred_label = np.argmax(pred_label.numpy(), axis=1)
correct_label += sum(labels == pred_label)
total_mse += loss_func(decoded, features['numeric'].numpy())
# encoded = aae.encoder(features['numeric'].numpy())
# output_wrt_dim(vae., features['numeric'].numpy()[0], field_names)
# forward_derviative(vae.decoder, encoded[0], ["dim{}".format(i) for i in range(latent_dim)])
# eval_with_different_label(aae, features["numeric"].numpy(), labels)
np.savetxt(latent_file, encoded, delimiter="\t")
np.savetxt(latent_label, labels, delimiter="\n")
np.savetxt(pred_label_file, pred_label, delimiter="\n")
scatter = plt.scatter(encoded.numpy()[:, 0],
encoded.numpy()[:, 1],
c=labels,
label=labels)
print("average mse:", total_mse / steps)
print("average label acc:", correct_label / 1024 / steps)
legend1 = plt.legend(*scatter.legend_elements(),
loc="lower left",
title="Classes")
f.add_artist(legend1)
f.tight_layout()
f.savefig('../experiment/aae_vis/scatter.png')
latent_file.close()
latent_label.close()
pred_label_file.close()
def train(configs, tuning=False, hparams=None):
"""
training adversarial autoencoders
Args:
configs (dict): training configurations.
tuning (boolean): whether the function should be ran under hyperparameter tuning mode. Defaults to False.
hparams (dict): hparams object, has to be supplied if tuning is True. Defaults to None.
Returns:
None
"""
batch_size = configs["batch_size"]
dataset_name = configs["dataset_name"]
train, val = load_dataset(dataset_name,
sets=configs["data_sets"],
label_name="category",
batch_size=batch_size)
supervised = configs["supervised"]
epochs = configs["epochs"]
# if not hyperparameter tuning, set up tensorboard
if not tuning:
logdir = "tensorboard_logs/aae/" + datetime.now().strftime(
"%Y%m%d-%H%M%S")
train_summary_writer = tf.summary.create_file_writer(logdir)
latent_dim = configs["latent_dim"]
intermediate_dim = configs["intermediate_dim"]
weight = configs["reconstruction_weight"]
else:
latent_dim = hparams[LATENT_DIMS]
intermediate_dim = hparams[INTERMEDIATE_DIM]
weight = hparams[RECON_WEIGHTS]
loss_weights = [weight, 1 - weight]
with open("../data/{}/metadata.txt".format(dataset_name)) as file:
metadata = json.load(file)
num_classes = metadata["num_classes"]
field_names = metadata["field_names"][:-1]
input_dim = len(field_names)
datamin = np.array(metadata["col_min"][:-1])
datamax = np.array(metadata["col_max"][:-1])
scaler, _ = min_max_scaler_gen(datamin, datamax)
#
packed_train_data = train.map(
PackNumericFeatures(field_names, num_classes, scaler=scaler))
packed_val_data = val.map(
PackNumericFeatures(field_names, num_classes, scaler=scaler))
# oop version does not provide a good graph trace so using functional instead
aae, encoder, decoder, discriminator = build_aae(input_dim,
intermediate_dim,
latent_dim,
supervised=supervised)
aae.compile(loss=['mse', 'binary_crossentropy'],
loss_weights=loss_weights,
optimizer='adam',
metrics=["mse", 'acc'])
valid = np.ones((batch_size, 1))
invalid = np.zeros((batch_size, 1))
step = 0
for epoch in range(epochs):
steps = metadata["num_train"] // batch_size
for feature, label in packed_train_data.take(steps):
input_feature = feature['numeric']
# train discriminator
discriminator.trainable = True
fake = encoder(input_feature)
real = sample_prior(latent_dim, batch_size, distro="uniform")
d_loss_real = discriminator.train_on_batch(real, valid)
d_loss_fake = discriminator.train_on_batch(fake, invalid)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
discriminator.trainable = False
# train generator
if supervised:
g_loss = aae.train_on_batch([input_feature, label],
[input_feature, valid])
else:
g_loss = aae.train_on_batch(input_feature,
[input_feature, valid])
# record losses if not tuning
if not tuning:
with train_summary_writer.as_default():
tf.summary.scalar('d loss', d_loss[0], step=step)
tf.summary.scalar('d acc', d_loss[1], step=step)
tf.summary.scalar('g loss', g_loss[0], step=step)
tf.summary.scalar('mse', g_loss[1], step=step)
step += 1
if epoch % 2 == 0:
print(
"epoch:{} [D loss: {:.3f}, acc: {:.3f}%] [G loss: {:.3f}, mse: {:.3f}, disc_loss: {:.3f}]"
.format(epoch, d_loss[0], 100 * d_loss[1], g_loss[0],
g_loss[1], g_loss[2]))
# when tuning return the tuning metric
if tuning:
train_step = metadata["num_train"] // batch_size
val_step = metadata["num_val"] // batch_size
return h_measure(packed_train_data, packed_val_data, train_step,
val_step, encoder, decoder)
else:
# other wise trace aae with dummy value and save model
feature, label = list(packed_val_data.take(1).as_numpy_iterator())[0]
feature = np.zeros((1, input_dim))
label = np.zeros((num_classes))
latent = np.zeros((1, latent_dim))
# trace aae
with train_summary_writer.as_default():
tf.summary.trace_on(graph=True, profiler=True)
if supervised:
tracer(aae, [feature, label])
else:
tracer(aae, feature)
tf.summary.trace_export(name="aae", step=0, profiler_outdir=logdir)
# trace each component
tf.summary.trace_on(graph=True, profiler=True)
embeddings = tracer(encoder, feature)
tf.summary.trace_export(name="encoder",
step=0,
profiler_outdir=logdir)
tf.summary.trace_on(graph=True, profiler=True)
if supervised:
tracer(decoder, [latent, label])
else:
tracer(decoder, latent)
tf.summary.trace_export(name="decoder",
step=0,
profiler_outdir=logdir)
tf.summary.trace_on(graph=True, profiler=True)
tracer(discriminator, latent)
tf.summary.trace_export(name="discriminator",
step=0,
profiler_outdir=logdir)
# tf.keras.models.save_model(aae, "../models/aae/test")
aae.save("../models/aae/aae.h5")
encoder.save("../models/aae/encoder.h5")
decoder.save("../models/aae/decoder.h5")
def train_label_aae(configs, tuning=False, hparams=None):
batch_size = configs["batch_size"]
dataset_name = configs["dataset_name"]
train, val = load_dataset(dataset_name,
sets=configs["data_sets"],
label_name="category",
batch_size=batch_size)
supervised = configs["supervised"]
epochs = configs["epochs"]
representation = configs["representation"]
# if not hyperparameter tuning, set up tensorboard
if not tuning:
logdir = "tensorboard_logs/aae/" + datetime.now().strftime(
"%Y%m%d-%H%M%S")
train_summary_writer = tf.summary.create_file_writer(logdir)
latent_dim = configs["latent_dim"]
intermediate_dim = configs["intermediate_dim"]
weight = configs["reconstruction_weight"]
else:
latent_dim = hparams[LATENT_DIMS]
intermediate_dim = hparams[INTERMEDIATE_DIM]
weight = hparams[RECON_WEIGHTS]
loss_weights = [weight, (1 - weight) / 2, (1 - weight) / 2]
with open("../data/{}/metadata.txt".format(dataset_name)) as file:
metadata = json.load(file)
num_classes = metadata["num_classes"]
field_names = metadata["field_names"][:-1]
input_dim = len(field_names)
datamin = np.array(metadata["col_min"][:-1])
datamax = np.array(metadata["col_max"][:-1])
scaler, _ = min_max_scaler_gen(datamin, datamax)
#
packed_train_data = train.map(
PackNumericFeatures(field_names, num_classes, scaler=scaler))
packed_val_data = val.map(
PackNumericFeatures(field_names, num_classes, scaler=scaler))
# oop version does not provide a good graph trace so using functional instead
aae, encoder, decoder, latent_discriminator, cat_discriminator = build_label_aae(
input_dim,
intermediate_dim,
latent_dim,
num_classes,
representation=representation)
aae.compile(loss=['mse', 'binary_crossentropy', 'binary_crossentropy'],
loss_weights=loss_weights,
optimizer='adam',
metrics=["mse", 'acc', 'acc'])
valid = np.ones((batch_size, 1))
invalid = np.zeros((batch_size, 1))
step = 0
for epoch in range(epochs):
steps = metadata["num_train"] // batch_size
for feature, label in packed_train_data.take(steps):
input_feature = feature['numeric']
fake_latent, fake_cat = encoder(input_feature)
# train latent discriminator
latent_discriminator.trainable = True
real_latent = sample_prior(batch_size,
distro="uniform",
latent_dim=latent_dim)
d_loss_real = latent_discriminator.train_on_batch(
real_latent, valid)
d_loss_fake = latent_discriminator.train_on_batch(
fake_latent, invalid)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
latent_discriminator.trainable = False
# train cat discriminator
cat_discriminator.trainable = True
# real_cat = sample_prior(
# batch_size, distro="categorical", num_classes=num_classes)
real_cat = label
cat_loss_real = cat_discriminator.train_on_batch(real_cat, valid)
cat_loss_fake = cat_discriminator.train_on_batch(fake_cat, invalid)
cat_loss = 0.5 * np.add(cat_loss_real, cat_loss_fake)
cat_discriminator.trainable = False
# train generator
g_loss = aae.train_on_batch(input_feature,
[input_feature, valid, valid])
# record losses if not tuning
if not tuning:
with train_summary_writer.as_default():
tf.summary.scalar('d loss', d_loss[0], step=step)
tf.summary.scalar('d acc', d_loss[1], step=step)
tf.summary.scalar('g loss', g_loss[0], step=step)
tf.summary.scalar('mse', g_loss[1], step=step)
step += 1
if epoch % 2 == 0:
print(
"epoch:{} [D lat loss: {:.3f}, acc: {:.3f}%] [D cat loss: {:.3f}, acc: {:.3f}%] [G loss: {:.3f}, mse: {:.3f}, disc_loss: {:.3f}]"
.format(epoch, d_loss[0], 100 * d_loss[1], cat_loss[0],
100 * cat_loss[1], g_loss[0], g_loss[1], g_loss[2]))
# when tuning return the tuning metric
if tuning:
train_step = metadata["num_train"] // batch_size
val_step = metadata["num_val"] // batch_size
return h_measure(packed_train_data, packed_val_data, train_step,
val_step, encoder, decoder)
else:
# other wise trace aae with dummy value and save model
feature, label = list(packed_val_data.take(1).as_numpy_iterator())[0]
feature = np.zeros((1, input_dim))
label = np.zeros((num_classes))
latent = np.zeros((1, latent_dim))
# trace aae
with train_summary_writer.as_default():
tf.summary.trace_on(graph=True, profiler=True)
tracer(aae, feature)
tf.summary.trace_export(name="aae", step=0, profiler_outdir=logdir)
# tf.keras.models.save_model(aae, "../models/aae/test")
aae.save("../models/aae/aae.h5")
encoder.save("../models/aae/encoder.h5")
decoder.save("../models/aae/decoder.h5")