def _test_complete_flow( self, train_input_fn, eval_input_fn, predict_input_fn, input_dimension, label_dimension, batch_size): feature_columns = [ feature_column.numeric_column('x', shape=(input_dimension,))] est = linear.LinearEstimator( head=head_lib._regression_head(label_dimension=label_dimension), 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.make_parse_example_spec(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, n_classes, batch_size): feature_columns = [ tf.feature_column.numeric_column('x', shape=(input_dimension,)) ] est = dnn.DNNClassifierV2( 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[tf.compat.v1.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 = tf.feature_column.make_parse_example_spec(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(tf.compat.v1.gfile.Exists(export_dir))
def test_complete_flow_with_no_tpu(self): # Choose the train_batch_size divisible by 2 and 8 (common shards in test # env) and batch_size for eval and predict prime number. train_batch_size = 16 eval_batch_size = 8 predict_batch_size = 1 run_config = create_run_config(iterations_per_loop=4) num_shards = run_config.tpu_config.num_shards (expected_batch_size_for_model_fn, expected_batch_size_for_input_fn, expected_called_count_for_input_fn) = ( self._generate_expected_batch_size_and_called_count( num_shards, train_batch_size, eval_batch_size, predict_batch_size, train_sharding_policy=_UNSHARDED, eval_sharding_policy=_UNSHARDED)) est = tpu_estimator.TPUEstimator( model_fn=self._make_model_fn( expected_batch_size_for_model_fn, use_tpu_estimator_spec=True), config=run_config, train_batch_size=train_batch_size, eval_batch_size=eval_batch_size, predict_batch_size=predict_batch_size, use_tpu=False) # TRAIN # learn y = x # Note: Gradients are all zero. Just testing execution. train_input_fn = self._make_input_fn(mode=_TRAIN, repeat=True) est.train(train_input_fn, steps=7) # EVALUTE eval_input_fn = self._make_input_fn(mode=_EVAL) scores = est.evaluate(eval_input_fn, steps=2) self.assertEqual(7, scores['global_step']) self.assertGreater(0.1, scores['absolute_error']) # PREDICT predict_input_fn = self._make_input_fn(mode=_PREDICT) predictions = [x['predictions'] for x in est.predict(predict_input_fn)] self.assertAllClose(self._data, predictions, atol=0.01) # Verify all input_fn invoke recorded metadata. self.assertInputFnCalledCountAndBatch( expected_called_count_for_input_fn, expected_batch_size_for_input_fn) # EXPORT feature_spec = {'x': tf.io.FixedLenFeature([1], tf.float32)} serving_input_receiver_fn = ( export.build_parsing_serving_input_receiver_fn(feature_spec)) with self.export_mode(): export_dir = est.export_saved_model( tempfile.mkdtemp(dir=self.get_temp_dir()), serving_input_receiver_fn) self.assertTrue(tf.gfile.Exists(export_dir)) self._test_identity_savedmodel(export_dir)
def test_build_parsing_serving_input_receiver_fn(self): feature_spec = { "int_feature": parsing_ops.VarLenFeature(dtypes.int64), "float_feature": parsing_ops.VarLenFeature(dtypes.float32) } serving_input_receiver_fn = export.build_parsing_serving_input_receiver_fn( feature_spec) with ops.Graph().as_default(): serving_input_receiver = serving_input_receiver_fn() self.assertEqual(set(["int_feature", "float_feature"]), set(serving_input_receiver.features.keys())) self.assertEqual( set(["examples"]), set(serving_input_receiver.receiver_tensors.keys())) example = example_pb2.Example() text_format.Parse( "features: { " " feature: { " " key: 'int_feature' " " value: { " " int64_list: { " " value: [ 21, 2, 5 ] " " } " " } " " } " " feature: { " " key: 'float_feature' " " value: { " " float_list: { " " value: [ 525.25 ] " " } " " } " " } " "} ", example) with self.cached_session() as sess: sparse_result = sess.run( serving_input_receiver.features, feed_dict={ serving_input_receiver.receiver_tensors["examples"].name: [example.SerializeToString()] }) self.assertAllEqual([[0, 0], [0, 1], [0, 2]], sparse_result["int_feature"].indices) self.assertAllEqual([21, 2, 5], sparse_result["int_feature"].values) self.assertAllEqual([[0, 0]], sparse_result["float_feature"].indices) self.assertAllEqual([525.25], sparse_result["float_feature"].values)
def _test_complete_flow(self, train_input_fn, eval_input_fn, predict_input_fn, input_dimension, label_dimension, batch_size, dnn_optimizer='Adagrad', linear_optimizer='Ftrl'): linear_feature_columns = [ feature_column_v2.numeric_column('x', shape=(input_dimension, )) ] dnn_feature_columns = [ feature_column_v2.numeric_column('x', shape=(input_dimension, )) ] feature_columns = linear_feature_columns + dnn_feature_columns est = dnn_linear_combined.DNNLinearCombinedEstimatorV2( head=regression_head.RegressionHead( label_dimension=label_dimension), linear_feature_columns=linear_feature_columns, dnn_feature_columns=dnn_feature_columns, dnn_hidden_units=(2, 2), model_dir=self._model_dir, dnn_optimizer=dnn_optimizer, linear_optimizer=linear_optimizer) # 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 _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.DNNRegressor(hidden_units=(2, 2), feature_columns=feature_columns, label_dimension=label_dimension, 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_savedmodel(tempfile.mkdtemp(), serving_input_receiver_fn) self.assertTrue(gfile.Exists(export_dir))
def _get_exporter(self, name, fc): feature_spec = tf.compat.v1.feature_column.make_parse_example_spec(fc) serving_input_receiver_fn = ( export_lib.build_parsing_serving_input_receiver_fn(feature_spec)) return exporter_lib.LatestExporter( name, serving_input_receiver_fn=serving_input_receiver_fn)
def _get_serving_input_receiver_fn(): feature_spec = {'x': parsing_ops.VarLenFeature(dtype=dtypes.int64), 'y': parsing_ops.VarLenFeature(dtype=dtypes.int64)} return export.build_parsing_serving_input_receiver_fn(feature_spec)