def test_input_fn(self):
feature_map, label = input_fn.get_input_fn(
tf.estimator.ModeKeys.TRAIN, [self.input_data_dir],
'label.in_hospital_death.class',
sequence_features=[
'Observation.code', 'Observation.value.quantity.value',
'Observation.value.quantity.unit',
'Observation.code.harmonized:valueset-observation-name'
],
dense_sequence_feature='Observation.value.quantity.value',
required_sequence_feature='Observation.code.harmonized:valueset-'
'observation-name',
batch_size=2,
shuffle=False)()
with self.test_session() as sess:
sess.run(tf.tables_initializer())
coord = tf.train.Coordinator()
tf.train.start_queue_runners(sess=sess, coord=coord)
feature_map.update(label)
results = sess.run(feature_map)
expected_dense_shape = [2, 3, 1]
expected_indices = [[0, 0, 0], [0, 1, 0], [0, 2, 0], [1, 0, 0]]
expected_code = [b'loinc:4', b'loinc:6', b'loinc:6', b'loinc:1']
expected_harm_code = [
b'pulse', b'temperature', b'temperature', b'pulse'
]
expected_value = [2.0, 20.0, -2.0, 1.0]
code = results['s-Observation.code']
self.assertAllEqual(expected_code, code.values)
self.assertAllEqual(expected_indices, code.indices)
self.assertAllEqual(expected_dense_shape, code.dense_shape)
harm_code = results[
's-Observation.code.harmonized:valueset-observation-name']
self.assertAllEqual(expected_harm_code, harm_code.values)
self.assertAllEqual(expected_indices, harm_code.indices)
self.assertAllEqual(expected_dense_shape, harm_code.dense_shape)
value = results['s-Observation.value.quantity.value']
self.assertAllClose(np.array(expected_value), value.values)
self.assertAllEqual(expected_indices, value.indices)
self.assertAllEqual(expected_dense_shape, value.dense_shape)
unit = results['s-Observation.value.quantity.unit']
self.assertAllEqual([b'F'], unit.values)
self.assertAllEqual([[0, 2, 0]], unit.indices)
self.assertAllEqual(expected_dense_shape, unit.dense_shape)
self.assertAllClose(results['label.in_hospital_death.class'],
np.array([[1.], [0.]]))
self.assertAllEqual([[3], [1]], results['c-sequenceLength'])
self.assertAllEqual([[[12], [11], [10]], [[12], [0], [0]]],
results['s-deltaTime'])
def test_model_integration(self):
features, labels = input_fn.get_input_fn(
tf.estimator.ModeKeys.TRAIN, [self.input_data_dir],
'label.in_hospital_death.class',
sequence_features=[
'Observation.code', 'Observation.value.quantity.value',
'Observation.value.quantity.unit',
'Observation.code.harmonized:valueset-observation-name'
],
dense_sequence_feature='Observation.value.quantity.value',
required_sequence_feature=
'Observation.code.harmonized:valueset-observation-name',
batch_size=2,
shuffle=False)()
num_steps = 2
hparams = contrib_training.HParams(
batch_size=2,
learning_rate=0.008,
sequence_features=[
'deltaTime', 'Observation.code',
'Observation.value.quantity.value'
],
categorical_values=['loinc:4', 'loinc:6', 'loinc:1'],
categorical_seq_feature='Observation.code',
context_features=['sequenceLength'],
feature_value='Observation.value.quantity.value',
label_key='label.in_hospital_death.class',
attribution_threshold=-1.0,
rnn_size=6,
variational_recurrent_keep_prob=1.1,
variational_input_keep_prob=1.1,
variational_output_keep_prob=1.1,
sequence_prediction=False,
time_decayed=False,
normalize=True,
momentum=0.9,
min_value=-1000.0,
max_value=1000.0,
volatility_loss_factor=0.0,
attribution_max_delta_time=100000,
input_keep_prob=1.0,
include_sequence_prediction=False,
include_gradients_attribution=True,
include_gradients_sum_time_attribution=False,
include_gradients_avg_time_attribution=False,
include_path_integrated_gradients_attribution=True,
include_diff_sequence_prediction_attribution=False,
use_rnn_attention=True,
attention_hidden_layer_dim=5,
path_integrated_gradients_num_steps=10,
)
model = osm.ObservationSequenceModel()
model_fn = model.create_model_fn(hparams)
with tf.variable_scope('test'):
model_fn_ops_train = model_fn(features, labels,
tf.estimator.ModeKeys.TRAIN)
with tf.variable_scope('test', reuse=True):
model_fn_ops_eval = model_fn(features,
labels=None,
mode=tf.estimator.ModeKeys.PREDICT)
with self.test_session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.tables_initializer())
# Test train.
for i in range(num_steps):
loss, _ = sess.run(
[model_fn_ops_train.loss, model_fn_ops_train.train_op])
if i == 0:
initial_loss = loss
self.assertLess(loss, initial_loss)
# Test infer.
sess.run(model_fn_ops_eval.predictions)
