def _parse_example(example):
ctx, seq = parsing_ops.parse_single_sequence_example(
example,
context_features=fc.make_parse_example_spec_v2(ctx_cols),
sequence_features=fc.make_parse_example_spec_v2(seq_cols))
ctx.update(seq)
return ctx
def _parse_example(example):
ctx, seq = parsing_ops.parse_single_sequence_example(
example,
context_features=fc.make_parse_example_spec_v2(ctx_cols),
sequence_features=fc.make_parse_example_spec_v2(seq_cols))
ctx.update(seq)
return ctx
def _test_parsed_sequence_example(
self, col_name, col_fn, col_arg, shape, values):
"""Helper function to check that each FeatureColumn parses correctly.
Args:
col_name: string, name to give to the feature column. Should match
the name that the column will parse out of the features dict.
col_fn: function used to create the feature column. For example,
sequence_numeric_column.
col_arg: second arg that the target feature column is expecting.
shape: the expected dense_shape of the feature after parsing into
a SparseTensor.
values: the expected values at index [0, 2, 6] of the feature
after parsing into a SparseTensor.
"""
example = _make_sequence_example()
columns = [
fc.categorical_column_with_identity('int_ctx', num_buckets=100),
fc.numeric_column('float_ctx'),
col_fn(col_name, col_arg)
]
context, seq_features = parsing_ops.parse_single_sequence_example(
example.SerializeToString(),
context_features=fc.make_parse_example_spec_v2(columns[:2]),
sequence_features=fc.make_parse_example_spec_v2(columns[2:]))
with self.cached_session() as sess:
ctx_result, seq_result = sess.run([context, seq_features])
self.assertEqual(list(seq_result[col_name].dense_shape), shape)
self.assertEqual(
list(seq_result[col_name].values[[0, 2, 6]]), values)
self.assertEqual(list(ctx_result['int_ctx'].dense_shape), [1])
self.assertEqual(ctx_result['int_ctx'].values[0], 5)
self.assertEqual(list(ctx_result['float_ctx'].shape), [1])
self.assertAlmostEqual(ctx_result['float_ctx'][0], 123.6, places=1)
def _test_parsed_sequence_example(self, col_name, col_fn, col_arg, shape,
values):
"""Helper function to check that each FeatureColumn parses correctly.
Args:
col_name: string, name to give to the feature column. Should match
the name that the column will parse out of the features dict.
col_fn: function used to create the feature column. For example,
sequence_numeric_column.
col_arg: second arg that the target feature column is expecting.
shape: the expected dense_shape of the feature after parsing into
a SparseTensor.
values: the expected values at index [0, 2, 6] of the feature
after parsing into a SparseTensor.
"""
example = _make_sequence_example()
columns = [
fc.categorical_column_with_identity('int_ctx', num_buckets=100),
fc.numeric_column('float_ctx'),
col_fn(col_name, col_arg)
]
context, seq_features = parsing_ops.parse_single_sequence_example(
example.SerializeToString(),
context_features=fc.make_parse_example_spec_v2(columns[:2]),
sequence_features=fc.make_parse_example_spec_v2(columns[2:]))
with self.cached_session() as sess:
ctx_result, seq_result = sess.run([context, seq_features])
self.assertEqual(list(seq_result[col_name].dense_shape), shape)
self.assertEqual(list(seq_result[col_name].values[[0, 2, 6]]),
values)
self.assertEqual(list(ctx_result['int_ctx'].dense_shape), [1])
self.assertEqual(ctx_result['int_ctx'].values[0], 5)
self.assertEqual(list(ctx_result['float_ctx'].shape), [1])
self.assertAlmostEqual(ctx_result['float_ctx'][0], 123.6, places=1)
def make_feature_tensors(self, serialized_examples_tensor):
ctx, seq, _ = parsing_ops.parse_sequence_example(
serialized_examples_tensor,
context_features=fc.make_parse_example_spec_v2(
self.context_features),
sequence_features=fc.make_parse_example_spec_v2(
self.sequence_features),
)
fs = {}
fs.update(ctx)
fs.update(seq)
return fs
def _test_complete_flow(self, train_input_fn, eval_input_fn, predict_input_fn,
input_dimension, n_classes, batch_size):
feature_columns = [feature_column_v2.numeric_column('x', shape=(input_dimension,))]
est = dnn.DNNClassifier(
hidden_units=(2, 2),
feature_columns=feature_columns,
n_classes=n_classes,
model_dir=self._model_dir)
# TRAIN
num_steps = 10
est.train(train_input_fn, steps=num_steps)
# EVALUATE
scores = est.evaluate(eval_input_fn)
self.assertEqual(num_steps, scores[ops.GraphKeys.GLOBAL_STEP])
self.assertIn('loss', six.iterkeys(scores))
# PREDICT
predicted_proba = np.array([
x[prediction_keys.PredictionKeys.PROBABILITIES]
for x in est.predict(predict_input_fn)
])
self.assertAllEqual((batch_size, n_classes), predicted_proba.shape)
# EXPORT
feature_spec = feature_column_v2.make_parse_example_spec_v2(feature_columns)
serving_input_receiver_fn = export.build_parsing_serving_input_receiver_fn(
feature_spec)
export_dir = est.export_savedmodel(tempfile.mkdtemp(),
serving_input_receiver_fn)
self.assertTrue(gfile.Exists(export_dir))
def _test_complete_flow(self, train_input_fn, eval_input_fn,
predict_input_fn, input_dimension, label_dimension,
prediction_length):
feature_columns = [
feature_column_lib.numeric_column('x', shape=(input_dimension, ))
]
est = _baseline_estimator_fn(label_dimension=label_dimension,
model_dir=self._model_dir)
# TRAIN
# learn y = x
est.train(train_input_fn, steps=200)
# EVALUTE
scores = est.evaluate(eval_input_fn)
self.assertEqual(200, scores[ops.GraphKeys.GLOBAL_STEP])
self.assertIn(metric_keys.MetricKeys.LOSS, six.iterkeys(scores))
# PREDICT
predictions = np.array(
[x['predictions'] for x in est.predict(predict_input_fn)])
self.assertAllEqual((prediction_length, label_dimension),
predictions.shape)
# EXPORT
feature_spec = feature_column_lib.make_parse_example_spec_v2(
feature_columns)
serving_input_receiver_fn = export.build_parsing_serving_input_receiver_fn(
feature_spec)
export_dir = est.export_saved_model(tempfile.mkdtemp(),
serving_input_receiver_fn)
self.assertTrue(gfile.Exists(export_dir))
def _test_complete_flow(self, train_input_fn, eval_input_fn, predict_input_fn,
input_dimension, label_dimension, batch_size):
feature_columns = [
feature_column_v2.numeric_column('x', shape=(input_dimension,))
]
est = dnn.DNNEstimatorV2(
head=regression_head.RegressionHead(label_dimension=label_dimension),
hidden_units=(2, 2),
feature_columns=feature_columns,
model_dir=self._model_dir)
# Train
num_steps = 10
est.train(train_input_fn, steps=num_steps)
# Evaluate
scores = est.evaluate(eval_input_fn)
self.assertEqual(num_steps, scores[ops.GraphKeys.GLOBAL_STEP])
self.assertIn('loss', six.iterkeys(scores))
# Predict
predictions = np.array([
x[prediction_keys.PredictionKeys.PREDICTIONS]
for x in est.predict(predict_input_fn)
])
self.assertAllEqual((batch_size, label_dimension), predictions.shape)
# Export
feature_spec = feature_column_v2.make_parse_example_spec_v2(feature_columns)
serving_input_receiver_fn = export.build_parsing_serving_input_receiver_fn(
feature_spec)
export_dir = est.export_saved_model(tempfile.mkdtemp(),
serving_input_receiver_fn)
self.assertTrue(gfile.Exists(export_dir))
def make_model_input_configs(self):
context_inputs = {}
for name, col in fc.make_parse_example_spec_v2(
self.context_features).items():
context_inputs[name] = tf.keras.Input(
shape=(None, ),
sparse=False,
name=name,
dtype=col.dtype,
)
sequence_inputs = {}
for name, col in fc.make_parse_example_spec_v2(
self.sequence_features).items():
sequence_inputs[name] = tf.keras.Input(
shape=(None, None),
sparse=True,
name=name,
dtype=col.dtype,
)
return context_inputs, sequence_inputs
def make_features_and_target_tensors(self, serialized_examples_tensor):
context_features = fc.make_parse_example_spec_v2(self.context_features)
context_targets = fc.make_parse_example_spec_v2(self.context_targets)
context_data = {}
context_data.update(context_features)
context_data.update(context_targets)
sequence_features = fc.make_parse_example_spec_v2(
self.sequence_features)
sequence_targets = fc.make_parse_example_spec_v2(self.sequence_targets)
sequence_data = {}
sequence_data.update(sequence_features)
sequence_data.update(sequence_targets)
ctx, seq, _ = parsing_ops.parse_sequence_example(
serialized_examples_tensor,
context_features=context_data,
sequence_features=sequence_data,
)
fs = {}
fs.update(
{name: t
for name, t in ctx.items() if name in context_features})
fs.update(
{name: t
for name, t in seq.items() if name in sequence_features})
ts = {}
ts.update(
{name: t
for name, t in ctx.items() if name in context_targets})
ts.update(
{name: t
for name, t in seq.items() if name in sequence_targets})
return fs, ts
def _test_complete_flow(self, train_input_fn, eval_input_fn, predict_input_fn,
input_dimension, label_dimension, batch_size,
fc_impl):
linear_feature_columns = [
fc_impl.numeric_column('x', shape=(input_dimension,))
]
dnn_feature_columns = [
fc_impl.numeric_column('x', shape=(input_dimension,))
]
feature_columns = linear_feature_columns + dnn_feature_columns
feature_spec = feature_column_v2.make_parse_example_spec_v2(feature_columns)
self._test_complete_flow_helper(linear_feature_columns, dnn_feature_columns,
feature_spec, train_input_fn, eval_input_fn,
predict_input_fn, input_dimension,
label_dimension, batch_size)
