def testNumpyInputFn(self):
a = np.arange(4) * 1.0
b = np.arange(32, 36)
x = {'a': a, 'b': b}
y = np.arange(-32, -28)
with self.cached_session() as session:
input_fn = numpy_io.numpy_input_fn(x,
y,
batch_size=2,
shuffle=False,
num_epochs=1)
features, target = input_fn()
coord = tf.train.Coordinator()
threads = tf.compat.v1.train.queue_runner.start_queue_runners(
session, coord=coord)
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [0, 1])
self.assertAllEqual(res[0]['b'], [32, 33])
self.assertAllEqual(res[1], [-32, -31])
session.run([features, target])
with self.assertRaises(tf.errors.OutOfRangeError):
session.run([features, target])
coord.request_stop()
coord.join(threads)
def testNumpyInputFnWithYAsDict(self):
a = np.arange(4) * 1.0
b = np.arange(32, 36)
x = {'a': a, 'b': b}
y = {'y1': np.arange(-32, -28), 'y2': np.arange(32, 28, -1)}
with self.cached_session() as session:
input_fn = numpy_io.numpy_input_fn(x,
y,
batch_size=2,
shuffle=False,
num_epochs=1)
features_tensor, targets_tensor = input_fn()
coord = coordinator.Coordinator()
threads = queue_runner_impl.start_queue_runners(session,
coord=coord)
features, targets = session.run([features_tensor, targets_tensor])
self.assertEqual(len(features), 2)
self.assertAllEqual(features['a'], [0, 1])
self.assertAllEqual(features['b'], [32, 33])
self.assertEqual(len(targets), 2)
self.assertAllEqual(targets['y1'], [-32, -31])
self.assertAllEqual(targets['y2'], [32, 31])
session.run([features_tensor, targets_tensor])
with self.assertRaises(errors.OutOfRangeError):
session.run([features_tensor, targets_tensor])
coord.request_stop()
coord.join(threads)
def testMultiDim(self):
"""Tests predict when all variables are multi-dimenstional."""
batch_size = 2
label_dimension = 3
with ops.Graph().as_default():
variables.Variable( # shape=[label_dimension]
[.2, .4, .6], name=BIAS_NAME)
variables.Variable(100, name='global_step', dtype=dtypes.int64)
save_variables_to_ckpt(self._model_dir)
baseline_estimator = _baseline_estimator_fn(
label_dimension=label_dimension,
model_dir=self._model_dir)
predict_input_fn = numpy_io.numpy_input_fn(
# x shape=[batch_size, x_dim]
x={'x': np.array([[1., 2., 3., 4.], [5., 6., 7., 8.]])},
y=None,
batch_size=batch_size,
num_epochs=1,
shuffle=False)
predictions = baseline_estimator.predict(input_fn=predict_input_fn)
predicted_scores = list([x['predictions'] for x in predictions])
# score = bias, shape=[batch_size, label_dimension]
self.assertAllClose([[0.2, 0.4, 0.6], [0.2, 0.4, 0.6]],
predicted_scores)
def testBinaryClassifierTrainInMemoryWithDataset(self):
train_input_fn = _make_train_input_fn_dataset(is_classification=True)
predict_input_fn = numpy_io.numpy_input_fn(x=FEATURES_DICT,
y=None,
batch_size=1,
num_epochs=1,
shuffle=False)
est = boosted_trees.boosted_trees_classifier_train_in_memory(
train_input_fn=train_input_fn,
feature_columns=self._feature_columns,
n_trees=1,
max_depth=5)
# It will stop after 5 steps because of the max depth and num trees.
self._assert_checkpoint(est.model_dir,
global_step=5,
finalized_trees=1,
attempted_layers=5)
# Check evaluate and predict.
eval_res = est.evaluate(input_fn=train_input_fn, steps=1)
self.assertAllClose(eval_res['accuracy'], 1.0)
predictions = list(est.predict(input_fn=predict_input_fn))
self.assertAllClose([[0], [1], [1], [0], [0]],
[pred['class_ids'] for pred in predictions])
def testRegressorTrainInMemoryWithDataset(self):
train_input_fn = _make_train_input_fn_dataset(is_classification=False)
predict_input_fn = numpy_io.numpy_input_fn(x=FEATURES_DICT,
y=None,
batch_size=1,
num_epochs=1,
shuffle=False)
est = boosted_trees.boosted_trees_regressor_train_in_memory(
train_input_fn=train_input_fn,
feature_columns=self._feature_columns,
n_trees=1,
max_depth=5)
# It will stop after 5 steps because of the max depth and num trees.
self._assert_checkpoint(est.model_dir,
global_step=5,
finalized_trees=1,
attempted_layers=5)
# Check evaluate and predict.
eval_res = est.evaluate(input_fn=train_input_fn, steps=1)
self.assertAllClose(eval_res['average_loss'], 2.478283)
predictions = list(est.predict(input_fn=predict_input_fn))
self.assertAllClose(
[[0.571619], [0.262821], [0.124549], [0.956801], [1.769801]],
[pred['predictions'] for pred in predictions])
def testBinaryClassifierTrainInMemoryAndEvalAndInferWithPrePruning(self):
train_input_fn = _make_train_input_fn(is_classification=True)
predict_input_fn = numpy_io.numpy_input_fn(x=FEATURES_DICT,
y=None,
batch_size=1,
num_epochs=1,
shuffle=False)
est = boosted_trees.boosted_trees_classifier_train_in_memory(
train_input_fn=train_input_fn,
feature_columns=self._feature_columns,
n_trees=1,
max_depth=5,
pruning_mode='pre',
tree_complexity=0.01)
# We stop actually after 2*depth*n_trees steps (via a hook) because we still
# could not grow 1 trees of depth 5 (due to pre-pruning).
self._assert_checkpoint(est.model_dir,
global_step=11,
finalized_trees=0,
attempted_layers=11)
# Check evaluate and predict.
eval_res = est.evaluate(input_fn=train_input_fn, steps=1)
self.assertAllClose(eval_res['accuracy'], 1.0)
# Validate predictions.
predictions = list(est.predict(input_fn=predict_input_fn))
self.assertAllClose([[0], [1], [1], [0], [0]],
[pred['class_ids'] for pred in predictions])
def testNumpyInputFnWithXIsEmptyArray(self):
x = np.array([[], []])
y = np.arange(4)
with self.cached_session():
with self.assertRaisesRegexp(ValueError, 'x cannot be an empty'):
failing_input_fn = numpy_io.numpy_input_fn(x, y, shuffle=False)
failing_input_fn()
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 testBinaryClassifierTrainInMemoryWithMixedColumns(self):
categorical = feature_column.categorical_column_with_vocabulary_list(
key='f_0', vocabulary_list=('bad', 'good', 'ok'))
indicator_col = feature_column.indicator_column(categorical)
bucketized_col = feature_column.bucketized_column(
feature_column.numeric_column('f_1', dtype=dtypes.float32),
BUCKET_BOUNDARIES)
numeric_col = feature_column.numeric_column('f_2', dtype=dtypes.float32)
labels = np.array([[0], [1], [1], [1], [1]], dtype=np.float32)
input_fn = numpy_io.numpy_input_fn(
x={
'f_0': np.array(['bad', 'good', 'good', 'ok', 'bad']),
'f_1': np.array([1, 1, 1, 1, 1]),
'f_2': np.array([12.5, 1.0, -2.001, -2.0001, -1.999]),
},
y=labels,
num_epochs=None,
batch_size=5,
shuffle=False)
feature_columns = [numeric_col, bucketized_col, indicator_col]
est = boosted_trees.boosted_trees_classifier_train_in_memory(
train_input_fn=input_fn,
feature_columns=feature_columns,
n_trees=1,
max_depth=5,
quantile_sketch_epsilon=0.33)
self._assert_checkpoint(
est.model_dir, global_step=5, finalized_trees=1, attempted_layers=5)
eval_res = est.evaluate(input_fn=input_fn, steps=1)
self.assertAllClose(eval_res['accuracy'], 1.0)
def testRegressorTrainInMemoryWithFloatColumns(self):
train_input_fn = _make_train_input_fn(is_classification=False)
predict_input_fn = numpy_io.numpy_input_fn(
x=FEATURES_DICT, y=None, batch_size=1, num_epochs=1, shuffle=False)
est = boosted_trees.boosted_trees_regressor_train_in_memory(
train_input_fn=train_input_fn,
feature_columns=self._numeric_feature_columns,
n_trees=1,
max_depth=5,
quantile_sketch_epsilon=0.33)
# It will stop after 5 steps because of the max depth and num trees.
self._assert_checkpoint(
est.model_dir,
global_step=5,
finalized_trees=1,
attempted_layers=5,
bucket_boundaries=[[-2.001, -1.999, 12.5], [-3., 0.4995, 2.],
[-100., 20., 102.75]])
# Check evaluate and predict.
eval_res = est.evaluate(input_fn=train_input_fn, steps=1)
self.assertAllClose(eval_res['average_loss'], 2.4182191)
predictions = list(est.predict(input_fn=predict_input_fn))
self.assertAllClose(
[[0.663432], [0.31798199], [0.081902], [0.75843203], [1.86384201]],
[pred['predictions'] for pred in predictions])
def test_dnn_and_linear_logits_are_added(self, fc_impl):
with ops.Graph().as_default():
variables_lib.Variable([[1.0]],
name='linear/linear_model/x/weights')
variables_lib.Variable([2.0],
name='linear/linear_model/bias_weights')
variables_lib.Variable([[3.0]], name='dnn/hiddenlayer_0/kernel')
variables_lib.Variable([4.0], name='dnn/hiddenlayer_0/bias')
variables_lib.Variable([[5.0]], name='dnn/logits/kernel')
variables_lib.Variable([6.0], name='dnn/logits/bias')
variables_lib.Variable(1, name='global_step', dtype=dtypes.int64)
linear_testing_utils.save_variables_to_ckpt(self._model_dir)
x_column = fc_impl.numeric_column('x')
est = dnn_linear_combined.DNNLinearCombinedRegressor(
linear_feature_columns=[x_column],
dnn_hidden_units=[1],
dnn_feature_columns=[x_column],
model_dir=self._model_dir)
input_fn = numpy_io.numpy_input_fn(x={'x': np.array([[10.]])},
batch_size=1,
shuffle=False)
# linear logits = 10*1 + 2 = 12
# dnn logits = (10*3 + 4)*5 + 6 = 176
# logits = dnn + linear = 176 + 12 = 188
self.assertAllClose(
{
prediction_keys.PredictionKeys.PREDICTIONS: [188.],
}, next(est.predict(input_fn=input_fn)))
def testInferEstimatorWithCenterBias(self):
train_input_fn = _make_train_input_fn(is_classification=False)
predict_input_fn = numpy_io.numpy_input_fn(
x=FEATURES_DICT, y=None, batch_size=1, num_epochs=1, shuffle=False)
est = boosted_trees._BoostedTreesEstimator(
feature_columns=self._feature_columns,
n_batches_per_layer=1,
n_trees=1,
max_depth=5,
center_bias=True,
head=self._head)
# It will stop after 6 steps because of the max depth and num trees (5 for
# training and 2 for bias centering).
num_steps = 100
# Train for a few steps, and validate final checkpoint.
est.train(train_input_fn, steps=num_steps)
self._assert_checkpoint(
est.model_dir, global_step=7, finalized_trees=1, attempted_layers=5)
# Validate predictions.
predictions = list(est.predict(input_fn=predict_input_fn))
self.assertAllClose(
[[1.634501], [1.325703], [1.187431], [2.019683], [2.832683]],
[pred['predictions'] for pred in predictions])
def testBinaryClassifierTrainInMemoryFloatColumns(self):
train_input_fn = _make_train_input_fn_dataset(is_classification=True)
predict_input_fn = numpy_io.numpy_input_fn(
x=FEATURES_DICT, y=None, batch_size=1, num_epochs=1, shuffle=False)
est = boosted_trees.boosted_trees_classifier_train_in_memory(
train_input_fn=train_input_fn,
feature_columns=self._numeric_feature_columns,
n_trees=1,
max_depth=5,
quantile_sketch_epsilon=0.33)
# It will stop after 5 steps because of the max depth and num trees.
self._assert_checkpoint(
est.model_dir,
global_step=5,
finalized_trees=1,
attempted_layers=5,
bucket_boundaries=[[-2.001, -1.999, 12.5], [-3., 0.4995, 2.],
[-100., 20., 102.75]])
eval_res = est.evaluate(input_fn=train_input_fn, steps=1)
self.assertAllClose(eval_res['accuracy'], 1.0)
predictions = list(est.predict(input_fn=predict_input_fn))
self.assertAllClose([[0], [1], [1], [0], [0]],
[pred['class_ids'] for pred in predictions])
def testNumpyInputFnWithYIsNone(self):
a = np.arange(4) * 1.0
b = np.arange(32, 36)
x = {'a': a, 'b': b}
y = None
with self.cached_session() as session:
input_fn = numpy_io.numpy_input_fn(x,
y,
batch_size=2,
shuffle=False,
num_epochs=1)
features_tensor = input_fn()
coord = tf.train.Coordinator()
threads = tf.compat.v1.train.queue_runner.start_queue_runners(
session, coord=coord)
feature = session.run(features_tensor)
self.assertEqual(len(feature), 2)
self.assertAllEqual(feature['a'], [0, 1])
self.assertAllEqual(feature['b'], [32, 33])
session.run([features_tensor])
with self.assertRaises(tf.errors.OutOfRangeError):
session.run([features_tensor])
coord.request_stop()
coord.join(threads)
def testNumpyInputFnWithVeryLargeBatchSizeAndMultipleEpochs(self):
a = np.arange(2) * 1.0
b = np.arange(32, 34)
x = {'a': a, 'b': b}
y = np.arange(-32, -30)
with self.cached_session() as session:
input_fn = numpy_io.numpy_input_fn(x,
y,
batch_size=128,
shuffle=False,
num_epochs=2)
features, target = input_fn()
coord = coordinator.Coordinator()
threads = queue_runner_impl.start_queue_runners(session,
coord=coord)
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [0, 1, 0, 1])
self.assertAllEqual(res[0]['b'], [32, 33, 32, 33])
self.assertAllEqual(res[1], [-32, -31, -32, -31])
with self.assertRaises(errors.OutOfRangeError):
session.run([features, target])
coord.request_stop()
coord.join(threads)
def test_train_with_dense_features(self):
feature_dict = {
'sex': np.int64([1, 1, 1, 1, 0]),
'cp': np.int64([0, 3, 3, 2, 1]),
'slope': np.int64([3, 2, 0, 3, 1]),
}
label = np.int64([0, 1, 0, 0, 0])
train_input_fn = numpy_io.numpy_input_fn(
x=feature_dict, y=label, num_epochs=1, shuffle=False)
feature_columns = list()
input_features = dict()
for feature_name, data_array in feature_dict.items():
feature_columns.append(
feature_column.indicator_column(
feature_column.categorical_column_with_identity(
key=feature_name,
num_buckets=np.size(np.unique(data_array)))))
input_features[feature_name] = keras.layers.Input(
name=feature_name,
shape=(np.size(np.unique(data_array)),),
dtype=dtypes.int64)
x = dense_features.DenseFeatures(feature_columns)(input_features)
x = keras.layers.Dense(16, activation='relu')(x)
logits = keras.layers.Dense(1, activation='linear')(x)
model = keras.Model(inputs=input_features, outputs=logits)
model.compile(
optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])
estimator_model = keras_lib.model_to_estimator(keras_model=model)
estimator_model.train(input_fn=train_input_fn, steps=5)
def testInferEstimator(self):
train_input_fn = _make_train_input_fn(is_classification=False)
predict_input_fn = numpy_io.numpy_input_fn(x=FEATURES_DICT,
y=None,
batch_size=1,
num_epochs=1,
shuffle=False)
est = boosted_trees._BoostedTreesEstimator(
feature_columns=self._feature_columns,
n_batches_per_layer=1,
n_trees=1,
max_depth=5,
head=self._head)
# It will stop after 5 steps because of the max depth and num trees.
num_steps = 100
# Train for a few steps, and validate final checkpoint.
est.train(train_input_fn, steps=num_steps)
self._assert_checkpoint(est.model_dir,
global_step=5,
finalized_trees=1,
attempted_layers=5)
# Validate predictions.
predictions = list(est.predict(input_fn=predict_input_fn))
self.assertAllClose(
[[0.571619], [0.262821], [0.124549], [0.956801], [1.769801]],
[pred['predictions'] for pred in predictions])
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.DNNLinearCombinedClassifier(
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 linear 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_evaluation_for_multi_dimensions(self):
label_dim = 2
with ops.Graph().as_default():
variables.Variable([46.0, 58.0], name=BIAS_NAME)
variables.Variable(100, name='global_step', dtype=dtypes.int64)
save_variables_to_ckpt(self._model_dir)
baseline_estimator = _baseline_estimator_fn(
label_dimension=label_dim,
model_dir=self._model_dir)
input_fn = numpy_io.numpy_input_fn(
x={
'age': np.array([[2., 4., 5.]]),
},
y=np.array([[46., 58.]]),
batch_size=1,
num_epochs=None,
shuffle=False)
eval_metrics = baseline_estimator.evaluate(input_fn=input_fn, steps=1)
self.assertItemsEqual(
(metric_keys.MetricKeys.LOSS, metric_keys.MetricKeys.LOSS_MEAN,
metric_keys.MetricKeys.PREDICTION_MEAN,
metric_keys.MetricKeys.LABEL_MEAN, ops.GraphKeys.GLOBAL_STEP),
eval_metrics.keys())
# Logit is bias which is [46, 58]
self.assertAlmostEqual(0, eval_metrics[metric_keys.MetricKeys.LOSS])
def testNumpyInputFnWithDifferentDimensionsOfFeatures(self):
a = np.array([[1, 2], [3, 4]])
b = np.array([5, 6])
x = {'a': a, 'b': b}
y = np.arange(-32, -30)
with self.cached_session() as session:
input_fn = numpy_io.numpy_input_fn(x,
y,
batch_size=2,
shuffle=False,
num_epochs=1)
features, target = input_fn()
coord = coordinator.Coordinator()
threads = queue_runner_impl.start_queue_runners(session,
coord=coord)
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [[1, 2], [3, 4]])
self.assertAllEqual(res[0]['b'], [5, 6])
self.assertAllEqual(res[1], [-32, -31])
coord.request_stop()
coord.join(threads)
def testNumpyInputFnWithBatchSizeLargerThanDataSize(self):
batch_size = 10
a = np.arange(4) * 1.0
b = np.arange(32, 36)
x = {'a': a, 'b': b}
y = np.arange(-32, -28)
with self.cached_session() as session:
input_fn = numpy_io.numpy_input_fn(x,
y,
batch_size=batch_size,
shuffle=False,
num_epochs=1)
features, target = input_fn()
coord = coordinator.Coordinator()
threads = queue_runner_impl.start_queue_runners(session,
coord=coord)
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [0, 1, 2, 3])
self.assertAllEqual(res[0]['b'], [32, 33, 34, 35])
self.assertAllEqual(res[1], [-32, -31, -30, -29])
with self.assertRaises(errors.OutOfRangeError):
session.run([features, target])
coord.request_stop()
coord.join(threads)
def _create_input_fn(self, label_dimension, batch_size):
"""Creates input_fn for integration test."""
data = np.linspace(0., 2., batch_size * label_dimension, dtype=np.float32)
data = data.reshape(batch_size, label_dimension)
# learn y = x
train_input_fn = numpy_io.numpy_input_fn(
x={'x': data},
y=data,
batch_size=batch_size,
num_epochs=None,
shuffle=True)
eval_input_fn = numpy_io.numpy_input_fn(
x={'x': data}, y=data, batch_size=batch_size, shuffle=False)
predict_input_fn = numpy_io.numpy_input_fn(
x={'x': data}, batch_size=batch_size, shuffle=False)
return train_input_fn, eval_input_fn, predict_input_fn
def testNumpyInputFn(self):
"""Tests complete flow with numpy_input_fn."""
n_classes = 3
batch_size = 10
words = ['dog', 'cat', 'bird', 'the', 'a', 'sat', 'flew', 'slept']
# Numpy only supports dense input, so all examples will have same length.
# TODO(b/73160931): Update test when support for prepadded data exists.
sequence_length = 3
features = []
for _ in range(batch_size):
sentence = random.sample(words, sequence_length)
features.append(sentence)
x_data = np.array(features)
y_data = np.random.randint(n_classes, size=batch_size)
train_input_fn = numpy_io.numpy_input_fn(
x={'tokens': x_data},
y=y_data,
batch_size=batch_size,
num_epochs=None,
shuffle=True)
eval_input_fn = numpy_io.numpy_input_fn(
x={'tokens': x_data},
y=y_data,
batch_size=batch_size,
shuffle=False)
predict_input_fn = numpy_io.numpy_input_fn(
x={'tokens': x_data},
batch_size=batch_size,
shuffle=False)
col = seq_fc.sequence_categorical_column_with_hash_bucket(
'tokens', hash_bucket_size=10)
embed = fc.embedding_column(col, dimension=2)
feature_columns = [embed]
self._test_complete_flow(
feature_columns=feature_columns,
train_input_fn=train_input_fn,
eval_input_fn=eval_input_fn,
predict_input_fn=predict_input_fn,
n_classes=n_classes,
batch_size=batch_size)
def testNumpyInputFnWithYIsEmptyDict(self):
a = np.arange(4) * 1.0
b = np.arange(32, 36)
x = {'a': a, 'b': b}
y = {}
with self.cached_session():
with self.assertRaisesRegexp(ValueError, 'y cannot be empty'):
failing_input_fn = numpy_io.numpy_input_fn(x, y, shuffle=False)
failing_input_fn()
def testNumpyInputFnWithXAsNonDict(self):
x = list(range(32, 36))
y = np.arange(4)
with self.cached_session():
with self.assertRaisesRegexp(TypeError,
'x must be a dict or array'):
failing_input_fn = numpy_io.numpy_input_fn(x,
y,
batch_size=2,
shuffle=False,
num_epochs=1)
failing_input_fn()
def test_train_premade_linear_model_with_dense_features(self):
vocab_list = ['alpha', 'beta', 'gamma']
vocab_val = [0.4, 0.6, 0.9]
data = np.random.choice(vocab_list, size=256)
y = np.zeros_like(data, dtype=np.float32)
for vocab, val in zip(vocab_list, vocab_val):
indices = np.where(data == vocab)
y[indices] = val + np.random.uniform(
low=-0.01, high=0.01, size=indices[0].shape)
cat_column = tf.feature_column.categorical_column_with_vocabulary_list(
key='symbol', vocabulary_list=vocab_list)
ind_column = tf.feature_column.indicator_column(cat_column)
keras_input = keras.layers.Input(name='symbol',
shape=3,
dtype=tf.dtypes.string)
feature_layer = dense_features.DenseFeatures([ind_column])
h = feature_layer({'symbol': keras_input})
linear_model = linear.LinearModel(units=1)
h = linear_model(h)
model = keras.Model(inputs=keras_input, outputs=h)
opt = gradient_descent.SGD(0.1)
model.compile(opt, 'mse', ['mse'])
train_input_fn = numpy_io.numpy_input_fn(x={'symbol': data},
y=y,
num_epochs=20,
shuffle=False)
eval_input_fn = numpy_io.numpy_input_fn(x={'symbol': data},
y=y,
num_epochs=20,
shuffle=False)
est = keras_lib.model_to_estimator(keras_model=model,
config=self._config,
checkpoint_format='saver')
before_eval_results = est.evaluate(input_fn=eval_input_fn, steps=1)
est.train(input_fn=train_input_fn, steps=30)
after_eval_results = est.evaluate(input_fn=eval_input_fn, steps=1)
self.assertLess(after_eval_results['loss'],
before_eval_results['loss'])
self.assertLess(after_eval_results['loss'], 0.05)
def testCheckpointCompatibleForRegressor(self):
label_dimension = 2
batch_size = 10
data = np.linspace(0., 2., batch_size * label_dimension, dtype=np.float32)
data = data.reshape(batch_size, label_dimension)
# learn y = x
train_input_fn = numpy_io.numpy_input_fn(
x={'x': data},
y=data,
batch_size=batch_size,
num_epochs=None,
shuffle=True)
predict_input_fn = numpy_io.numpy_input_fn(
x={'x': data}, batch_size=batch_size, shuffle=False)
self._testCheckpointCompatibleWithNonAnnotatedEstimator(
train_input_fn,
predict_input_fn,
dnn.DNNRegressor,
dnn_with_layer_annotations.DNNRegressorWithLayerAnnotations,
prediction_key=prediction_keys.PredictionKeys.PREDICTIONS,
estimator_args={'label_dimension': label_dimension})
def testNumpyInputFnWithBatchSizeNotDividedByDataSizeAndMultipleEpochs(
self):
batch_size = 2
a = np.arange(3) * 1.0
b = np.arange(32, 35)
x = {'a': a, 'b': b}
y = np.arange(-32, -29)
with self.cached_session() as session:
input_fn = numpy_io.numpy_input_fn(x,
y,
batch_size=batch_size,
shuffle=False,
num_epochs=3)
features, target = input_fn()
coord = coordinator.Coordinator()
threads = queue_runner_impl.start_queue_runners(session,
coord=coord)
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [0, 1])
self.assertAllEqual(res[0]['b'], [32, 33])
self.assertAllEqual(res[1], [-32, -31])
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [2, 0])
self.assertAllEqual(res[0]['b'], [34, 32])
self.assertAllEqual(res[1], [-30, -32])
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [1, 2])
self.assertAllEqual(res[0]['b'], [33, 34])
self.assertAllEqual(res[1], [-31, -30])
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [0, 1])
self.assertAllEqual(res[0]['b'], [32, 33])
self.assertAllEqual(res[1], [-32, -31])
res = session.run([features, target])
self.assertAllEqual(res[0]['a'], [2])
self.assertAllEqual(res[0]['b'], [34])
self.assertAllEqual(res[1], [-30])
with self.assertRaises(errors.OutOfRangeError):
session.run([features, target])
coord.request_stop()
coord.join(threads)
def test_train_vs_eval_mode(self):
data = self._create_data()
train_input_fn = numpy_io.numpy_input_fn(
x={'x': data},
y=data,
batch_size=self._batch_size,
num_epochs=None,
shuffle=True)
eval_input_fn = numpy_io.numpy_input_fn(
x={'x': data}, y=data, batch_size=self._batch_size, shuffle=False)
est = self._get_estimator()
with patch.object(
tf.compat.v2.keras.layers.DenseFeatures, 'call',
return_value=data) as mock_dense_features_call:
est.train(train_input_fn, steps=10)
est.evaluate(eval_input_fn)
train_args, eval_args = mock_dense_features_call.call_args_list
# DenseFeature should have been called with training = True in train.
_, train_training_kwarg = train_args
self.assertTrue(train_training_kwarg['training'])
# DenseFeature should have been called with training = False in eval.
_, eval_training_kwarg = eval_args
self.assertFalse(eval_training_kwarg['training'])
def testNumpyInputFnWithDuplicateKeysInXAndY(self):
a = np.arange(4) * 1.0
b = np.arange(32, 36)
x = {'a': a, 'b': b}
y = {
'y1': np.arange(-32, -28),
'a': a,
'y2': np.arange(32, 28, -1),
'b': b
}
with self.cached_session():
with self.assertRaisesRegexp(
ValueError, '2 duplicate keys are found in both x and y'):
failing_input_fn = numpy_io.numpy_input_fn(x, y, shuffle=False)
failing_input_fn()
