def serving_input_receiver_fn():
feature_spec = {
'dense_input':
parsing_ops.FixedLenFeature([1], dtype=dtypes.float32)
}
return export_lib.build_parsing_serving_input_receiver_fn(
feature_spec)
def setUp(self):
super().setUp()
feature_spec = {'x': parsing_ops.FixedLenFeature([1], dtypes.float32)}
self._serving_input_receiver_fn = (
export_lib.build_parsing_serving_input_receiver_fn(feature_spec))
feature_spec = {
'x':
array_ops.placeholder(dtype=dtypes.float32, shape=(2, 1), name='x'),
}
label_spec = array_ops.placeholder(
dtype=dtypes.float32, shape=(1, 1), name='truth')
self._supervised_input_receiver_fn = (
export_lib.build_raw_supervised_input_receiver_fn(
feature_spec, label_spec))
def test_complete_flow_with_mode(self, distribution,
use_train_and_evaluate):
label_dimension = 2
input_dimension = label_dimension
batch_size = 10
data = np.linspace(0.,
2.,
batch_size * label_dimension,
dtype=np.float32)
data = data.reshape(batch_size, label_dimension)
train_input_fn = self.dataset_input_fn(
x={'x': data},
y=data,
batch_size=batch_size // distribution.num_replicas_in_sync,
shuffle=True)
eval_input_fn = self.dataset_input_fn(
x={'x': data},
y=data,
batch_size=batch_size // distribution.num_replicas_in_sync,
shuffle=False)
predict_input_fn = numpy_io.numpy_input_fn(x={'x': data},
batch_size=batch_size,
shuffle=False)
linear_feature_columns = [
tf.feature_column.numeric_column('x', shape=(input_dimension, ))
]
dnn_feature_columns = [
tf.feature_column.numeric_column('x', shape=(input_dimension, ))
]
feature_columns = linear_feature_columns + dnn_feature_columns
estimator = dnn_linear_combined.DNNLinearCombinedRegressor(
linear_feature_columns=linear_feature_columns,
dnn_hidden_units=(2, 2),
dnn_feature_columns=dnn_feature_columns,
label_dimension=label_dimension,
model_dir=self._model_dir,
# TODO(isaprykin): Work around the colocate_with error.
dnn_optimizer='Adagrad',
linear_optimizer='Adagrad',
config=run_config.RunConfig(train_distribute=distribution,
eval_distribute=distribution))
num_steps = 10
if use_train_and_evaluate:
scores, _ = training.train_and_evaluate(
estimator,
training.TrainSpec(train_input_fn, max_steps=num_steps),
training.EvalSpec(eval_input_fn))
else:
estimator.train(train_input_fn, steps=num_steps)
scores = estimator.evaluate(eval_input_fn)
self.assertEqual(num_steps, scores[tf.compat.v1.GraphKeys.GLOBAL_STEP])
self.assertIn('loss', scores)
predictions = np.array([
x[prediction_keys.PredictionKeys.PREDICTIONS]
for x in estimator.predict(predict_input_fn)
])
self.assertAllEqual((batch_size, label_dimension), predictions.shape)
feature_spec = tf.compat.v1.feature_column.make_parse_example_spec(
feature_columns)
serving_input_receiver_fn = export.build_parsing_serving_input_receiver_fn(
feature_spec)
export_dir = estimator.export_saved_model(tempfile.mkdtemp(),
serving_input_receiver_fn)
self.assertTrue(tf.compat.v1.gfile.Exists(export_dir))
def setUp(self):
super().setUp()
feature_spec = {'x': parsing_ops.FixedLenFeature([1], dtypes.float32)}
self._serving_input_receiver_fn = (
export_lib.build_parsing_serving_input_receiver_fn(feature_spec))
def serving_input_receiver_fn():
feature_spec = {
'a': tf.io.FixedLenFeature([1], dtype=tf.dtypes.float32),
'b': tf.io.FixedLenFeature([1], dtype=tf.dtypes.float32),
}
return export_lib.build_parsing_serving_input_receiver_fn(feature_spec)