def evaluate_classifier(loop):
with loop.timeit('cls_test_time'):
[c_pred] = collect_outputs(outputs=[q_y_given_x],
inputs=[input_x],
data_flow=test_flow,
feed_dict={is_training: False})
y_pred = c_classifier.predict(c_pred)
cls_metrics = {'test_acc': accuracy_score(y_test, y_pred)}
loop.collect_metrics(cls_metrics)
results.update_metrics(cls_metrics)
def train_classifier(loop):
df = DataFlow.arrays([x_train], batch_size=config.batch_size). \
map(input_x_sampler)
with loop.timeit('cls_train_time'):
[c_pred] = collect_outputs(outputs=[y_given_x],
inputs=[input_x],
data_flow=df,
feed_dict={is_training: False})
c_classifier.fit(c_pred, y_train)
print(c_classifier.describe())
def train_classifier(loop):
df = bernoulli_flow(
x_train, config.batch_size, shuffle=False, skip_incomplete=False)
with loop.timeit('cls_train_time'):
[c_pred] = collect_outputs(
outputs=[q_y_given_x],
inputs=[input_x],
data_flow=df,
)
c_classifier.fit(c_pred, y_train)
print(c_classifier.describe())
def main(trainpath, normalpath, abnormalpath, outputpath):
if config.debug_level == -1:
spt.utils.set_assertion_enabled(False)
elif config.debug_level == 1:
spt.utils.set_check_numerics(True)
#spt.utils.set_assertion_enabled(False)
# print the config
print_with_title('Configurations', config.format_config(), after='\n')
# input and output file
train_file = trainpath
normal_file = normalpath
abnormal_file = abnormalpath
output_file = os.path.join('webankdata',
'{}_{}.csv'.format(config.flow_type or 'vae',
outputpath))
valid_file = os.path.join('webankdata',
'v{}_{}.csv'.format(config.flow_type or 'vae',
outputpath))
# you can change it by yourself
# read data
(x_train, y_train), (x_test, y_test), flows_test = \
get_data_vae(train_file, normal_file, abnormal_file)
config.x_dim = x_train.shape[1]
#config.z_dim = get_z_dim(x_train.shape[1])
all_len = x_train.shape[0]
print('origin data: %s' % all_len)
for i in range(30):
print(list(x_train[i]))
valid_rate = 0.1
x_train, x_valid = train_test_split(x_train, test_size=valid_rate)
# x_valid = x_train
print('%s for validation, %s for training v2' % (x_valid.shape[0], x_train.shape[0]))
print('%s for test' % x_test.shape[0])
print('x_dim: %s z_dim: %s' % (config.x_dim, config.z_dim))
# change it by yourself
# input placeholders
input_x = tf.placeholder(
dtype=tf.float32, shape=(None, config.x_dim), name='input_x')
learning_rate = spt.AnnealingVariable(
'learning_rate', config.initial_lr, config.lr_anneal_factor)
# build the posterior flow
if config.flow_type is None:
posterior_flow = None
elif config.flow_type == 'planar_nf':
posterior_flow = \
spt.layers.planar_normalizing_flows(config.n_planar_nf_layers)
else:
assert(config.flow_type == 'rnvp')
with tf.variable_scope('posterior_flow'):
flows = []
for i in range(config.n_rnvp_layers):
flows.append(spt.layers.ActNorm())
flows.append(spt.layers.CouplingLayer(
tf.make_template(
'coupling',
coupling_layer_shift_and_scale,
create_scope_now_=True
),
scale_type='sigmoid'
))
flows.append(spt.layers.InvertibleDense(strict_invertible=True))
posterior_flow = spt.layers.SequentialFlow(flows=flows)
# derive the initialization op
with tf.name_scope('initialization'), \
arg_scope([spt.layers.act_norm], initializing=True):
init_q_net = q_net(input_x, posterior_flow)
init_chain = init_q_net.chain(
p_net, latent_axis=0, observed={'x': input_x})
init_loss = tf.reduce_mean(init_chain.vi.training.sgvb())
# derive the loss and lower-bound for training
with tf.name_scope('training'):
train_q_net = q_net(input_x, posterior_flow)
train_chain = train_q_net.chain(
p_net, latent_axis=0, observed={'x': input_x})
vae_loss = tf.reduce_mean(train_chain.vi.training.sgvb())
loss = vae_loss + tf.losses.get_regularization_loss()
# derive the nll and logits output for testing
with tf.name_scope('testing'):
test_q_net = q_net(input_x, posterior_flow, n_z=config.test_n_z)
test_chain = test_q_net.chain(
p_net, latent_axis=0, observed={'x': input_x})
test_logp = test_chain.vi.evaluation.is_loglikelihood()
test_nll = -tf.reduce_mean(test_logp)
test_lb = tf.reduce_mean(test_chain.vi.lower_bound.elbo())
# derive the optimizer
with tf.name_scope('optimizing'):
optimizer = tf.train.AdamOptimizer(learning_rate)
params = tf.trainable_variables()
grads = optimizer.compute_gradients(loss, var_list=params)
cliped_grad = []
for grad, var in grads:
if grad is not None and var is not None:
if config.norm_clip is not None:
grad = tf.clip_by_norm(grad, config.norm_clip)
cliped_grad.append((grad, var))
with tf.control_dependencies(
tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
train_op = optimizer.apply_gradients(cliped_grad)
train_flow = spt.DataFlow.arrays([x_train],
config.batch_size,
shuffle=True,
skip_incomplete=True)
valid_flow = spt.DataFlow.arrays([x_valid],
config.test_batch_size)
test_flow = spt.DataFlow.arrays([x_test],
config.test_batch_size)
# model_file
#model_name = ''
model_name = os.path.join(
'webankdata',
'md_{}_{}.model'.format(
config.flow_type or 'vae',
outputpath.split('.')[0]
)
)
with spt.utils.create_session().as_default() as session:
var_dict = spt.utils.get_variables_as_dict()
saver = spt.VariableSaver(var_dict, model_name)
#if os.path.exists(model_name):
if False:
print('%s exists' % model_name)
saver.restore()
else:
print('no model here, and start training')
# initialize the network
spt.utils.ensure_variables_initialized()
for [batch_x] in train_flow:
print('Network initialization loss: {:.6g}'.
format(session.run(init_loss, {input_x: batch_x})))
print('')
break
# train the network
with spt.TrainLoop(params,
var_groups=['p_net', 'q_net', 'posterior_flow'],
max_epoch=config.max_epoch,
max_step=config.max_step,
early_stopping=True,
valid_metric_name='valid_loss',
valid_metric_smaller_is_better=True) as loop:
trainer = spt.Trainer(
loop, train_op, [input_x], train_flow,
metrics={'loss': loss}
)
trainer.anneal_after(
learning_rate,
epochs=config.lr_anneal_epoch_freq,
steps=config.lr_anneal_step_freq
)
evaluator = spt.Evaluator(
loop,
metrics={'valid_loss': test_nll},
inputs=[input_x],
data_flow=valid_flow,
time_metric_name='valid_time'
)
trainer.evaluate_after_epochs(evaluator, freq=10)
trainer.log_after_epochs(freq=1)
trainer.run()
saver.save()
# get the answer
print('start testing')
start = time.time()
test_ans = collect_outputs([test_logp], [input_x], test_flow)[0] \
/ config.x_dim
end = time.time()
print("test time: ", end-start)
pd.DataFrame(
{'id': flows_test, 'label': y_test, 'score': test_ans}) \
.to_csv(output_file, index=False)
valid_ans = collect_outputs([test_logp], [input_x], valid_flow)[0] \
/ config.x_dim
pd.DataFrame({'score': valid_ans}).to_csv(valid_file, index=False)