def test_embeddings_distribution(make_categories):
"""Test initialising embedding variational layers with distributions."""
x, K = make_categories
N = len(x)
S = 3
x_, X_ = _make_placeholders(x, S, tf.int32)
output, KL = ab.EmbedVariational(output_dim=D, n_categories=K)(X_)
tc = tf.test.TestCase()
with tc.test_session():
tf.global_variables_initializer().run()
Phi = output.eval(feed_dict={x_: x})
assert Phi.shape == (S, N, D)
assert KL.eval() >= 0.
def test_dense_embeddings(make_categories):
"""Test the embedding layer."""
x, K = make_categories
N = len(x)
S = 3
x_, X_ = _make_placeholders(x, S, tf.int32)
output, KL = ab.EmbedVariational(output_dim=D, n_categories=K)(X_)
tc = tf.test.TestCase()
with tc.test_session():
tf.global_variables_initializer().run()
kl = KL.eval()
assert np.isscalar(kl)
assert kl > 0
Phi = output.eval(feed_dict={x_: x})
assert Phi.shape == (S, N, D)
def main():
"""Run the demo."""
# Get Continuous and categorical data
df_train, df_test = fetch_data()
df = pd.concat((df_train, df_test))
X_con, X_cat, n_cats, Y = input_fn(df)
# Define the continuous layers
con_layer = (ab.InputLayer(name='con', n_samples=T_SAMPLES) >>
ab.DenseVariational(output_dim=5, full=True))
# Now define the cateogrical layers, which we embed
# Note every embed_var call can be different, this is just "lazy"
cat_layer_list = [ab.EmbedVariational(EMBED_DIMS, i) for i in n_cats]
cat_layer = (
ab.InputLayer(name='cat', n_samples=T_SAMPLES) >> ab.PerFeature(
*cat_layer_list) # Assign columns to an embedding layers
)
# Now we can feed the initial continuous and cateogrical layers to further
# "joint" layers after we concatenate them
net = ab.stack(ab.Concat(con_layer, cat_layer),
ab.RandomArcCosine(100, 1.),
ab.DenseVariational(output_dim=1, full=True))
# Split data into training and testing
Xt_con, Xs_con = np.split(X_con, [len(df_train)], axis=0)
Xt_cat, Xs_cat = np.split(X_cat, [len(df_train)], axis=0)
Yt, Ys = np.split(Y, [len(df_train)], axis=0)
# Graph place holders
X_con_ = tf.placeholder(tf.float32, [None, Xt_con.shape[1]])
X_cat_ = tf.placeholder(tf.int32, [None, Xt_cat.shape[1]])
Y_ = tf.placeholder(tf.float32, [None, 1])
# Feed dicts
train_dict = {X_con_: Xt_con, X_cat_: Xt_cat, Y_: Yt}
test_dict = {X_con_: Xs_con, X_cat_: Xs_cat}
# Make model
N = len(Xt_con)
nn, kl = net(con=X_con_, cat=X_cat_)
likelihood = tf.distributions.Bernoulli(logits=nn)
loss = ab.elbo(likelihood, Y_, N, kl)
optimizer = tf.train.AdamOptimizer()
train = optimizer.minimize(loss)
init = tf.global_variables_initializer()
with tf.Session(config=CONFIG):
init.run()
# We're going to just use a feed_dict to feed in batches, which we
# generate here
batches = ab.batch(train_dict, batch_size=BSIZE, n_iter=NITER)
for i, data in enumerate(batches):
train.run(feed_dict=data)
if i % 1000 == 0:
loss_val = loss.eval(feed_dict=data)
print("Iteration {}, loss = {}".format(i, loss_val))
# Predict
Ep = ab.predict_expected(nn, test_dict, P_SAMPLES)
Ey = Ep > 0.5 # Max probability assignment
acc = accuracy_score(Ys.flatten(), Ey.flatten())
logloss = log_loss(Ys.flatten(), np.hstack((1 - Ep, Ep)))
print("Accuracy = {}, log loss = {}".format(acc, logloss))