def test_checkpoint_and_export(self):
model_dir = tempfile.mkdtemp()
config = run_config_lib.RunConfig(save_checkpoints_steps=3)
est = dnn.DNNClassifier(n_classes=3,
feature_columns=[
feature_column.real_valued_column(
'feature', dimension=4)
],
hidden_units=[3, 3],
model_dir=model_dir,
config=config)
exp_strategy = saved_model_export_utils.make_export_strategy(
est, 'export_input', exports_to_keep=None)
ex = experiment.Experiment(
est,
train_input_fn=test_data.iris_input_multiclass_fn,
eval_input_fn=test_data.iris_input_multiclass_fn,
export_strategies=(exp_strategy, ),
train_steps=8,
checkpoint_and_export=True,
eval_delay_secs=0)
with test.mock.patch.object(ex, '_maybe_export'):
with test.mock.patch.object(ex, '_call_evaluate'):
ex.train_and_evaluate()
# Eval and export are called after steps 1, 4, 7, and 8 (after training
# is completed).
self.assertEqual(ex._maybe_export.call_count, 4)
self.assertEqual(ex._call_evaluate.call_count, 4)
def testIrisDNN(self):
iris = base.load_iris()
feature_columns = [feature_column.real_valued_column("", dimension=4)]
classifier = dnn.DNNClassifier(
feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=3,
config=run_config.RunConfig(tf_random_seed=1))
classifier.fit(iris.data, iris.target, max_steps=200)
variable_names = classifier.get_variable_names()
self.assertEqual(
classifier.get_variable_value("dnn/hiddenlayer_0/weights").shape,
(4, 10))
self.assertEqual(
classifier.get_variable_value("dnn/hiddenlayer_1/weights").shape,
(10, 20))
self.assertEqual(
classifier.get_variable_value("dnn/hiddenlayer_2/weights").shape,
(20, 10))
self.assertEqual(
classifier.get_variable_value("dnn/logits/weights").shape, (10, 3))
self.assertIn("dnn/hiddenlayer_0/biases", variable_names)
self.assertIn("dnn/hiddenlayer_1/biases", variable_names)
self.assertIn("dnn/hiddenlayer_2/biases", variable_names)
self.assertIn("dnn/logits/biases", variable_names)
def testDNNDropout0(self):
# Dropout prob == 0.
iris = base.load_iris()
feature_columns = [feature_column.real_valued_column("", dimension=4)]
classifier = dnn.DNNClassifier(
feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=3,
dropout=0.0,
config=run_config.RunConfig(tf_random_seed=1))
classifier.fit(iris.data, iris.target, max_steps=200)
def testIrisDNN(self):
iris = base.load_iris()
feature_columns = [feature_column.real_valued_column("", dimension=4)]
classifier = dnn.DNNClassifier(
feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=3,
config=run_config.RunConfig(tf_random_seed=1))
classifier.fit(iris.data, iris.target, max_steps=200)
weights = classifier.weights_
self.assertEqual(weights[0].shape, (4, 10))
self.assertEqual(weights[1].shape, (10, 20))
self.assertEqual(weights[2].shape, (20, 10))
self.assertEqual(weights[3].shape, (10, 3))
biases = classifier.bias_
self.assertEqual(len(biases), 4)
def benchmarkLogisticFloatLabel(self):
def _input_fn(num_epochs=None):
features = {
'age':
input_lib.limit_epochs(constant_op.constant(
((50, ), (20, ), (10, ))),
num_epochs=num_epochs),
'language':
sparse_tensor.SparseTensor(values=input_lib.limit_epochs(
('en', 'fr', 'zh'), num_epochs=num_epochs),
indices=((0, 0), (0, 1), (2, 0)),
dense_shape=(3, 2))
}
return features, constant_op.constant(((0.8, ), (0., ), (0.2, )),
dtype=dtypes.float32)
lang_column = feature_column.sparse_column_with_hash_bucket(
'language', hash_bucket_size=20)
n_classes = 2
classifier = dnn.DNNClassifier(
n_classes=n_classes,
feature_columns=(feature_column.embedding_column(lang_column,
dimension=1),
feature_column.real_valued_column('age')),
hidden_units=(3, 3),
config=run_config.RunConfig(tf_random_seed=1))
steps = 1000
metrics = classifier.fit(input_fn=_input_fn,
steps=steps).evaluate(input_fn=_input_fn,
steps=1)
estimator_test_utils.assert_in_range(steps, steps + 5, 'global_step',
metrics)
# Prediction probabilities mirror the labels column, which proves that the
# classifier learns from float input.
self._report_metrics(metrics)
self._report_predictions(
classifier=classifier,
input_fn=functools.partial(_input_fn, num_epochs=1),
iters=metrics['global_step'],
n_examples=3,
n_classes=n_classes,
expected_probabilities=((0.2, 0.8), (1., 0.), (0.8, 0.2)),
expected_classes=(1, 0, 0),
benchmark_name_override=(
'DNNClassifierBenchmark.benchmarkLogisticFloatLabel_predictions'
))
def benchmarkLogisticMatrixData(self):
classifier = dnn.DNNClassifier(
feature_columns=(feature_column.real_valued_column('feature',
dimension=4), ),
hidden_units=(3, 3),
config=run_config.RunConfig(tf_random_seed=1))
input_fn = test_data.iris_input_logistic_fn
steps = 400
metrics = classifier.fit(input_fn=input_fn,
steps=steps).evaluate(input_fn=input_fn,
steps=1)
estimator_test_utils.assert_in_range(steps, steps + 5, 'global_step',
metrics)
estimator_test_utils.assert_in_range(0.9, 1.0, 'accuracy', metrics)
estimator_test_utils.assert_in_range(0.0, 0.3, 'loss', metrics)
self._report_metrics(metrics)
def benchmarkLogisticTensorData(self):
def _input_fn(num_epochs=None):
features = {
'age':
input_lib.limit_epochs(constant_op.constant(
((.8, ), (0.2, ), (.1, ))),
num_epochs=num_epochs),
'language':
sparse_tensor.SparseTensor(values=input_lib.limit_epochs(
('en', 'fr', 'zh'), num_epochs=num_epochs),
indices=((0, 0), (0, 1), (2, 0)),
dense_shape=(3, 2))
}
return features, constant_op.constant(((1, ), (0, ), (0, )),
dtype=dtypes.int32)
lang_column = feature_column.sparse_column_with_hash_bucket(
'language', hash_bucket_size=20)
classifier = dnn.DNNClassifier(
feature_columns=(feature_column.embedding_column(lang_column,
dimension=1),
feature_column.real_valued_column('age')),
hidden_units=(3, 3),
config=run_config.RunConfig(tf_random_seed=1))
steps = 100
metrics = classifier.fit(input_fn=_input_fn,
steps=steps).evaluate(input_fn=_input_fn,
steps=1)
estimator_test_utils.assert_in_range(steps, steps + 5, 'global_step',
metrics)
estimator_test_utils.assert_in_range(0.9, 1.0, 'accuracy', metrics)
estimator_test_utils.assert_in_range(0.0, 0.3, 'loss', metrics)
self._report_metrics(metrics)
self._report_predictions(
classifier=classifier,
input_fn=functools.partial(_input_fn, num_epochs=1),
iters=metrics['global_step'],
n_examples=3,
n_classes=2,
expected_classes=(1, 0, 0),
benchmark_name_override=(
'DNNClassifierBenchmark.benchmarkLogisticTensorData_predictions'
))
def benchmarkLogisticNpMatrixData(self):
classifier = dnn.DNNClassifier(
feature_columns=(feature_column.real_valued_column('',
dimension=4), ),
hidden_units=(3, 3),
config=run_config.RunConfig(tf_random_seed=1))
iris = test_data.prepare_iris_data_for_logistic_regression()
train_x = iris.data
train_y = iris.target
steps = 100
metrics = classifier.fit(x=train_x, y=train_y,
steps=steps).evaluate(x=train_x,
y=train_y,
steps=1)
estimator_test_utils.assert_in_range(steps, steps + 5, 'global_step',
metrics)
estimator_test_utils.assert_in_range(0.8, 1.0, 'accuracy', metrics)
self._report_metrics(metrics)
def benchmarkMultiClassMatrixData(self):
"""Tests multi-class classification using matrix data as input."""
classifier = dnn.DNNClassifier(
n_classes=3,
feature_columns=(feature_column.real_valued_column('feature',
dimension=4), ),
hidden_units=(3, 3),
config=run_config.RunConfig(tf_random_seed=1))
input_fn = test_data.iris_input_multiclass_fn
steps = 500
metrics = classifier.fit(input_fn=input_fn,
steps=steps).evaluate(input_fn=input_fn,
steps=1)
estimator_test_utils.assert_in_range(steps, steps + 5, 'global_step',
metrics)
estimator_test_utils.assert_in_range(0.9, 1.0, 'accuracy', metrics)
estimator_test_utils.assert_in_range(0.0, 0.4, 'loss', metrics)
self._report_metrics(metrics)
def benchmarkLogisticMatrixDataLabels1D(self):
def _input_fn():
iris = test_data.prepare_iris_data_for_logistic_regression()
return {
'feature': constant_op.constant(iris.data,
dtype=dtypes.float32)
}, constant_op.constant(iris.target,
shape=(100, ),
dtype=dtypes.int32)
classifier = dnn.DNNClassifier(
feature_columns=(feature_column.real_valued_column('feature',
dimension=4), ),
hidden_units=(3, 3),
config=run_config.RunConfig(tf_random_seed=1))
steps = 1000
metrics = classifier.fit(input_fn=_input_fn,
steps=steps).evaluate(input_fn=_input_fn,
steps=1)
estimator_test_utils.assert_in_range(steps, steps + 5, 'global_step',
metrics)
estimator_test_utils.assert_in_range(0.9, 1.0, 'accuracy', metrics)
self._report_metrics(metrics)
