def test_warm_starting_selective_variables(self, fc_impl):
"""Tests selecting variables to warm-start."""
age = fc_impl.numeric_column('age')
city = fc_impl.embedding_column(
fc_impl.categorical_column_with_vocabulary_list(
'city', vocabulary_list=['Mountain View', 'Palo Alto']),
dimension=5)
# Create a DNNLinearCombinedClassifier and train to save a checkpoint.
dnn_lc_classifier = dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=[age],
dnn_feature_columns=[city],
dnn_hidden_units=[256, 128],
model_dir=self._ckpt_and_vocab_dir,
n_classes=4,
linear_optimizer='SGD',
dnn_optimizer='SGD')
dnn_lc_classifier.train(input_fn=self._input_fn, max_steps=1)
# Create a second DNNLinearCombinedClassifier, warm-started from the first.
# Use a learning_rate = 0.0 optimizer to check values (use SGD so we don't
# have accumulator values that change).
warm_started_dnn_lc_classifier = (
dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=[age],
dnn_feature_columns=[city],
dnn_hidden_units=[256, 128],
n_classes=4,
linear_optimizer=gradient_descent.GradientDescentOptimizer(
learning_rate=0.0),
dnn_optimizer=gradient_descent_v2.SGD(learning_rate=0.0),
# The provided regular expression will only warm-start the deep
# portion of the model.
warm_start_from=estimator.WarmStartSettings(
ckpt_to_initialize_from=dnn_lc_classifier.model_dir,
vars_to_warm_start='.*(dnn).*')))
warm_started_dnn_lc_classifier.train(input_fn=self._input_fn,
max_steps=1)
for variable_name in warm_started_dnn_lc_classifier.get_variable_names(
):
if 'dnn' in variable_name:
if 'learning_rate' in variable_name:
self.assertAllClose(
0.0,
warm_started_dnn_lc_classifier.get_variable_value(
variable_name))
else:
self.assertAllClose(
dnn_lc_classifier.get_variable_value(variable_name),
warm_started_dnn_lc_classifier.get_variable_value(
variable_name))
elif 'linear' in variable_name:
linear_values = warm_started_dnn_lc_classifier.get_variable_value(
variable_name)
# Since they're not warm-started, the linear weights will be
# zero-initialized.
self.assertAllClose(np.zeros_like(linear_values),
linear_values)
def test_classifier_basic_warm_starting(self, fc_impl):
"""Tests correctness of DNNLinearCombinedClassifier default warm-start."""
age = fc_impl.numeric_column('age')
city = fc_impl.embedding_column(
fc_impl.categorical_column_with_vocabulary_list(
'city', vocabulary_list=['Mountain View', 'Palo Alto']),
dimension=5)
# Create a DNNLinearCombinedClassifier and train to save a checkpoint.
dnn_lc_classifier = dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=[age],
dnn_feature_columns=[city],
dnn_hidden_units=[256, 128],
model_dir=self._ckpt_and_vocab_dir,
n_classes=4,
linear_optimizer='SGD',
dnn_optimizer='SGD')
dnn_lc_classifier.train(input_fn=self._input_fn, max_steps=1)
# Create a second DNNLinearCombinedClassifier, warm-started from the first.
# Use a learning_rate = 0.0 optimizer to check values (use SGD so we don't
# have accumulator values that change).
# To avoid optimizer naming issue during warm start, when to create the
# optimizer instance, the dnn_optimizer needs to be created first
# before the linear_optimizer, since this is the order pre-defined
# in the model function.
# Create a default graph context to make sure the optimizer instance is
# created within Graph v1 to make it consistent with estimator Graph.
with tf.Graph().as_default():
warm_started_dnn_lc_classifier = (
dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=[age],
dnn_feature_columns=[city],
dnn_hidden_units=[256, 128],
n_classes=4,
dnn_optimizer=gradient_descent_v2.SGD(learning_rate=0.0),
linear_optimizer=gradient_descent_v2.SGD(
learning_rate=0.0),
warm_start_from=dnn_lc_classifier.model_dir))
warm_started_dnn_lc_classifier.train(input_fn=self._input_fn,
max_steps=1)
for variable_name in warm_started_dnn_lc_classifier.get_variable_names(
):
if 'learning_rate' in variable_name:
self.assertAllClose(
0.0,
warm_started_dnn_lc_classifier.get_variable_value(
variable_name))
else:
self.assertAllClose(
dnn_lc_classifier.get_variable_value(variable_name),
warm_started_dnn_lc_classifier.get_variable_value(
variable_name))
def test_train_op_calls_both_dnn_and_linear(self, fc_impl):
opt = gradient_descent.GradientDescentOptimizer(1.)
x_column = fc_impl.numeric_column('x')
input_fn = numpy_io.numpy_input_fn(x={'x': np.array([[0.], [1.]])},
y=np.array([[0.], [1.]]),
batch_size=1,
shuffle=False)
est = dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=[x_column],
# verifies linear_optimizer is used only for linear part.
linear_optimizer=self._mock_optimizer(opt, 'linear'),
dnn_hidden_units=(2, 2),
dnn_feature_columns=[x_column],
# verifies dnn_optimizer is used only for dnn part.
dnn_optimizer=self._mock_optimizer(opt, 'dnn'),
model_dir=self._model_dir)
est.train(input_fn, steps=1)
# verifies train_op fires linear minimize op
self.assertEqual(
100.,
checkpoint_utils.load_variable(self._model_dir, 'linear_called'))
# verifies train_op fires dnn minimize op
self.assertEqual(
100., checkpoint_utils.load_variable(self._model_dir,
'dnn_called'))
def test_train_op_calls_both_dnn_and_linear(self, fc_impl):
dnn_opt = gradient_descent_v2.SGD(1.)
linear_opt = gradient_descent_v2.SGD(1.)
x_column = fc_impl.numeric_column('x')
input_fn = numpy_io.numpy_input_fn(x={'x': np.array([[0.], [1.]])},
y=np.array([[0.], [1.]]),
batch_size=1,
shuffle=False)
est = dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=[x_column],
# verifies linear_optimizer is used only for linear part.
linear_optimizer=linear_opt,
dnn_hidden_units=(2, 2),
dnn_feature_columns=[x_column],
# verifies dnn_optimizer is used only for dnn part.
dnn_optimizer=dnn_opt,
model_dir=self._model_dir)
num_steps = 1
est.train(input_fn, steps=num_steps)
# verifies train_op fires linear minimize op
self.assertEqual(num_steps,
est.get_variable_value(linear_opt.iterations.name))
# verifies train_op fires dnn optmizer
self.assertEqual(num_steps,
est.get_variable_value(dnn_opt.iterations.name))
def test_classifier_basic_warm_starting(self, fc_impl):
"""Tests correctness of DNNLinearCombinedClassifier default warm-start."""
self.skipTest("b/133320890 causes naming issue during warm starting")
age = fc_impl.numeric_column('age')
city = fc_impl.embedding_column(
fc_impl.categorical_column_with_vocabulary_list(
'city', vocabulary_list=['Mountain View', 'Palo Alto']),
dimension=5)
# Create a DNNLinearCombinedClassifier and train to save a checkpoint.
dnn_lc_classifier = dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=[age],
dnn_feature_columns=[city],
dnn_hidden_units=[256, 128],
model_dir=self._ckpt_and_vocab_dir,
n_classes=4,
linear_optimizer='SGD',
dnn_optimizer='SGD')
dnn_lc_classifier.train(input_fn=self._input_fn, max_steps=1)
# Create a second DNNLinearCombinedClassifier, warm-started from the first.
# Use a learning_rate = 0.0 optimizer to check values (use SGD so we don't
# have accumulator values that change).
warm_started_dnn_lc_classifier = (
dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=[age],
dnn_feature_columns=[city],
dnn_hidden_units=[256, 128],
n_classes=4,
linear_optimizer=gradient_descent_v2.SGD(learning_rate=0.0),
dnn_optimizer=gradient_descent_v2.SGD(learning_rate=0.0),
warm_start_from=dnn_lc_classifier.model_dir))
warm_started_dnn_lc_classifier.train(input_fn=self._input_fn,
max_steps=1)
for variable_name in warm_started_dnn_lc_classifier.get_variable_names(
):
if 'learning_rate' in variable_name:
self.assertAllClose(
0.0,
warm_started_dnn_lc_classifier.get_variable_value(
variable_name))
else:
self.assertAllClose(
dnn_lc_classifier.get_variable_value(variable_name),
warm_started_dnn_lc_classifier.get_variable_value(
variable_name))
def _dnn_classifier_fn(hidden_units,
feature_columns,
model_dir=None,
n_classes=2,
weight_column=None,
label_vocabulary=None,
optimizer='Adagrad',
config=None):
return dnn_linear_combined.DNNLinearCombinedClassifierV2(
model_dir=model_dir,
dnn_hidden_units=hidden_units,
dnn_feature_columns=feature_columns,
dnn_optimizer=optimizer,
n_classes=n_classes,
weight_column=weight_column,
label_vocabulary=label_vocabulary,
config=config)
def _linear_classifier_fn(feature_columns,
model_dir=None,
n_classes=2,
weight_column=None,
label_vocabulary=None,
optimizer='Ftrl',
config=None,
sparse_combiner='sum'):
return dnn_linear_combined.DNNLinearCombinedClassifierV2(
model_dir=model_dir,
linear_feature_columns=feature_columns,
linear_optimizer=optimizer,
n_classes=n_classes,
weight_column=weight_column,
label_vocabulary=label_vocabulary,
config=config,
linear_sparse_combiner=sparse_combiner)
def _test_complete_flow(self, train_input_fn, eval_input_fn,
predict_input_fn, input_dimension, n_classes,
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
est = dnn_linear_combined.DNNLinearCombinedClassifierV2(
linear_feature_columns=linear_feature_columns,
dnn_hidden_units=(2, 2),
dnn_feature_columns=dnn_feature_columns,
n_classes=n_classes,
model_dir=self._model_dir)
# TRAIN
num_steps = 10
est.train(train_input_fn, steps=num_steps)
# EVALUTE
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_saved_model(tempfile.mkdtemp(),
serving_input_receiver_fn)
self.assertTrue(gfile.Exists(export_dir))
