def test_numeric_column_multi_dim(self):
"""Tests sequence_input_layer for multi-dimensional numeric_column."""
sparse_input = sparse_tensor.SparseTensorValue(
# example 0, values [[[0., 1.], [2., 3.]], [[4., 5.], [6., 7.]]]
# example 1, [[[10., 11.], [12., 13.]]]
indices=((0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6),
(0, 7), (1, 0), (1, 1), (1, 2), (1, 3)),
values=(0., 1., 2., 3., 4., 5., 6., 7., 10., 11., 12., 13.),
dense_shape=(2, 8))
# The output of numeric_column._get_dense_tensor should be flattened.
expected_input_layer = [
[[0., 1., 2., 3.], [4., 5., 6., 7.]],
[[10., 11., 12., 13.], [0., 0., 0., 0.]],
]
expected_sequence_length = [2, 1]
numeric_column = sfc.sequence_numeric_column('aaa', shape=(2, 2))
input_layer, sequence_length = sfc.sequence_input_layer(
features={'aaa': sparse_input}, feature_columns=[numeric_column])
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(expected_input_layer,
input_layer.eval(session=sess))
self.assertAllEqual(expected_sequence_length,
sequence_length.eval(session=sess))
def __init__(self,
estimator,
serving_input_receiver_fn,
output_key=None,
graph=None,
config=None):
"""Initialize a `CoreEstimatorPredictor`.
Args:
estimator: an instance of `learn.python.estimator.Estimator`.
serving_input_receiver_fn: a function that takes no arguments and returns
an instance of `ServingInputReceiver` compatible with `estimator`.
output_key: Optional string specifying the export output to use. If
`None`, then `DEFAULT_SERVING_SIGNATURE_DEF_KEY` is used.
graph: Optional. The Tensorflow `graph` in which prediction should be
done.
config: `ConfigProto` proto used to configure the session.
"""
self._graph = graph or ops.Graph()
with self._graph.as_default():
serving_input_receiver = serving_input_receiver_fn()
signature_def = _get_signature_def(
serving_input_receiver, estimator, output_key)
checkpoint_dir = estimator.model_dir
self._session = monitored_session.MonitoredSession(
session_creator=monitored_session.ChiefSessionCreator(
config=config,
checkpoint_dir=checkpoint_dir))
feed_tensor_info = signature_def.inputs
self._feed_tensors = {k: self._graph.get_tensor_by_name(v.name)
for k, v in feed_tensor_info.items()}
fetch_tensor_info = signature_def.outputs
self._fetch_tensors = {k: self._graph.get_tensor_by_name(v.name)
for k, v in fetch_tensor_info.items()}
def _between_graph_with_monitored_session(self, strategy):
context = distribute_coordinator_context.get_current_worker_context()
self.assertTrue(context is not None)
with ops.device("/job:ps/task:0"):
# TODO(yuefengz): investigate why not using resource variable will make
# the test flaky.
x = variable_scope.get_variable("xx", initializer=10.0, use_resource=True)
with ops.device("/job:ps/task:1"):
y = variable_scope.get_variable("yy", initializer=20.0, use_resource=True)
x_add = x.assign_add(2.0)
y_sub = y.assign_sub(2.0)
train_op = control_flow_ops.group([x_add, y_sub])
# The monitored session will run init or ready ops.
with monitored_session.MonitoredSession() as sess:
sess.run(train_op)
# Synchronize workers after one step to make sure they all have finished
# training.
if context.has_barrier:
context.wait_for_other_workers()
else:
self._barrier.wait()
x_val, y_val = sess.run([x, y])
self.assertEqual(x_val, 16.0)
self.assertEqual(y_val, 14.0)
if x_val == 16.0 and y_val == 14.0:
with self._lock:
self._result_correct += 1
def test_get_sequence_dense_tensor(self):
vocabulary_size = 3
sparse_input = sparse_tensor.SparseTensorValue(
# example 0, ids [2]
# example 1, ids [0, 1]
# example 2, ids []
# example 3, ids [1]
indices=((0, 0), (1, 0), (1, 1), (3, 0)),
values=(2, 0, 1, 1),
dense_shape=(4, 2))
expected_lookups = [
# example 0, ids [2]
[[0., 0., 1.], [0., 0., 0.]],
# example 1, ids [0, 1]
[[1., 0., 0.], [0., 1., 0.]],
# example 2, ids []
[[0., 0., 0.], [0., 0., 0.]],
# example 3, ids [1]
[[0., 1., 0.], [0., 0., 0.]],
]
categorical_column = sfc.sequence_categorical_column_with_identity(
key='aaa', num_buckets=vocabulary_size)
indicator_column = sfc._sequence_indicator_column(categorical_column)
indicator_tensor, _ = indicator_column._get_sequence_dense_tensor(
_LazyBuilder({'aaa': sparse_input}))
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(expected_lookups,
indicator_tensor.eval(session=sess))
def _decode_infer_model(input_fn,
feed_fn=None,
model_fn=None,
runCfg=None,
model_dir=None,
outputs=None,
as_iterable=True,
iterate_batches=False):
# Check that model has been trained.
checkpoint_path = saver.latest_checkpoint(model_dir)
if not checkpoint_path:
raise NotFittedError("Couldn't find trained model at %s." % model_dir)
with tf.Graph().as_default() as g:
random_seed.set_random_seed(runCfg.tf_random_seed)
contrib_framework.create_global_step(g)
features = input_fn()
model_result, _, _ = model_fn(features,
None,
mode=tf.contrib.learn.ModeKeys.INFER)
mon_sess = monitored_session.MonitoredSession(
session_creator=monitored_session.ChiefSessionCreator(
checkpoint_filename_with_path=checkpoint_path,
scaffold=None,
config=runCfg._session_config))
return _decode_predict_generator(mon_sess, model_result, feed_fn,
iterate_batches)
def testArrayAndDictGiveSameOutput(self):
a = np.arange(4) * 1.0
b = np.arange(32, 36)
x_arr = np.vstack((a, b))
x_dict = {'feature1': x_arr}
y = np.arange(-48, -40).reshape(2, 4)
input_fn_arr = numpy_io.numpy_input_fn(x_arr,
y,
batch_size=2,
shuffle=False,
num_epochs=1)
features_arr, targets_arr = input_fn_arr()
input_fn_dict = numpy_io.numpy_input_fn(x_dict,
y,
batch_size=2,
shuffle=False,
num_epochs=1)
features_dict, targets_dict = input_fn_dict()
with monitored_session.MonitoredSession() as session:
res_arr, res_dict = session.run([(features_arr, targets_arr),
(features_dict, targets_dict)])
self.assertAllEqual(res_arr[0], res_dict[0]['feature1'])
self.assertAllEqual(res_arr[1], res_dict[1])
def test_sequence_length_with_empty_rows(self):
"""Tests _sequence_length when some examples do not have ids."""
vocabulary_size = 3
sparse_input = sparse_tensor.SparseTensorValue(
# example 0, ids []
# example 1, ids [2]
# example 2, ids [0, 1]
# example 3, ids []
# example 4, ids [1]
# example 5, ids []
indices=((1, 0), (2, 0), (2, 1), (4, 0)),
values=(2, 0, 1, 1),
dense_shape=(6, 2))
expected_sequence_length = [0, 1, 2, 0, 1, 0]
categorical_column = sfc.sequence_categorical_column_with_identity(
key='aaa', num_buckets=vocabulary_size)
indicator_column = sfc._sequence_indicator_column(categorical_column)
_, sequence_length = indicator_column._get_sequence_dense_tensor(
_LazyBuilder({'aaa': sparse_input}))
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(expected_sequence_length,
sequence_length.eval(session=sess))
def testSessionRunHook(self):
a = array_ops.placeholder(dtypes.float32, [10])
b = a + 1
c = b * 2
class Hook(session_run_hook.SessionRunHook):
def before_run(self, _):
return session_run_hook.SessionRunArgs(fetches=c)
class Hook2(session_run_hook.SessionRunHook):
def before_run(self, _):
return session_run_hook.SessionRunArgs(fetches=b)
sess = session.Session()
sess = LocalCLIDebuggerWrapperSessionForTest([["run"], ["run"]], sess)
class SessionCreator(object):
def create_session(self):
return sess
final_sess = monitored_session.MonitoredSession(
session_creator=SessionCreator(), hooks=[Hook(), Hook2()])
final_sess.run(b, feed_dict={a: np.arange(10)})
debug_dumps = sess.observers["debug_dumps"]
self.assertEqual(1, len(debug_dumps))
debug_dump = debug_dumps[0]
node_names = [datum.node_name for datum in debug_dump.dumped_tensor_data]
self.assertIn(b.op.name, node_names)
def run(checkpoint, batch_size, dataset_name, images_path):
# Create model
images_placeholder, endpoints = create_model(batch_size, dataset_name)
# Load pre-trained model
session_creator = monitored_session.ChiefSessionCreator(
checkpoint_filename_with_path=checkpoint)
# Find images
img_names = os.listdir(images_path)
img_names.sort()
print("\nNumber of images to process : ", len(img_names))
img_paths = [images_path + img_name for img_name in img_names]
print("Number of images paths : ", len(img_paths))
global_results = []
with monitored_session.MonitoredSession(
session_creator=session_creator) as sess:
# Loop per batch of size 1
for i, img_path in enumerate(img_paths):
print("\nNew Image :", img_path)
images_data = load_images([img_path], batch_size, dataset_name)
predictions = sess.run(endpoints.predicted_text,
feed_dict={images_placeholder: images_data})
result = [
pr_bytes.decode('utf-8') for pr_bytes in predictions.tolist()
]
for line in result:
print(result)
global_results.append(line)
print("Image :", i)
return global_results
def test_get_sequence_dense_tensor_with_normalizer_fn(self):
def _increment_two(input_sparse_tensor):
return sparse_ops.sparse_add(
input_sparse_tensor,
sparse_tensor.SparseTensor(((0, 0), (1, 1)), (2.0, 2.0), (2, 2))
)
sparse_input = sparse_tensor.SparseTensorValue(
# example 0, values [[0.], [1]]
# example 1, [[10.]]
indices=((0, 0), (0, 1), (1, 0)),
values=(0., 1., 10.),
dense_shape=(2, 2))
# Before _increment_two:
# [[0.], [1.]],
# [[10.], [0.]],
# After _increment_two:
# [[2.], [1.]],
# [[10.], [2.]],
expected_dense_tensor = [
[[2.], [1.]],
[[10.], [2.]],
]
numeric_column = sfc.sequence_numeric_column(
'aaa', normalizer_fn=_increment_two)
dense_tensor, _ = numeric_column._get_sequence_dense_tensor(
_LazyBuilder({'aaa': sparse_input}))
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(
expected_dense_tensor, dense_tensor.eval(session=sess))
def test_sequence_length_not_equal(self):
"""Tests that an error is raised when sequence lengths are not equal."""
# Input a with sequence_length = [2, 1]
sparse_input_a = sparse_tensor.SparseTensorValue(indices=((0, 0),
(0, 1), (1,
0)),
values=(0., 1., 10.),
dense_shape=(2, 2))
# Input b with sequence_length = [1, 1]
sparse_input_b = sparse_tensor.SparseTensorValue(indices=((0, 0), (1,
0)),
values=(1., 10.),
dense_shape=(2, 2))
numeric_column_a = sfc.sequence_numeric_column('aaa')
numeric_column_b = sfc.sequence_numeric_column('bbb')
_, sequence_length = sfc.sequence_input_layer(
features={
'aaa': sparse_input_a,
'bbb': sparse_input_b,
},
feature_columns=[numeric_column_a, numeric_column_b])
with monitored_session.MonitoredSession() as sess:
with self.assertRaisesRegexp(
errors.InvalidArgumentError,
r'\[Condition x == y did not hold element-wise:\] '
r'\[x \(sequence_input_layer/aaa/sequence_length:0\) = \] \[2 1\] '
r'\[y \(sequence_input_layer/bbb/sequence_length:0\) = \] \[1 1\]'
):
sess.run(sequence_length)
def get_monitored_session(checkpoint_path):
session_creator = monitored_session.ChiefSessionCreator(
checkpoint_filename_with_path=checkpoint_path,
# scaffold=scaffold,
# master=master,
# config=config
)
return monitored_session.MonitoredSession(session_creator=session_creator)
def run(checkpoint, batch_size, dataset_name, image_path_pattern):
images_placeholder, endpoints = create_model(batch_size, dataset_name)
images_data = load_images(image_path_pattern, batch_size, dataset_name)
session_creator = monitored_session.ChiefSessionCreator(
checkpoint_filename_with_path=checkpoint)
with monitored_session.MonitoredSession(
session_creator=session_creator) as sess:
predictions = sess.run(endpoints.predicted_text,
feed_dict={images_placeholder: images_data})
return [pr_bytes.decode('utf-8') for pr_bytes in predictions.tolist()]
def outliers_detection(checkpoint_dir):
"""Find outliers using Euclidean distance in the last dense layer.
Parameters:
checkpoint_dir: Checkpoint of the saved model during training.
"""
with tf.Graph().as_default():
config = _CONFIG.copy()
config['mode'] = 'validation'
model = DeepSentiment(config)
# Load model
checkpoint_path = tf_saver.latest_checkpoint(checkpoint_dir)
scaffold = monitored_session.Scaffold(init_op=None,
init_feed_dict=None,
init_fn=None,
saver=None)
session_creator = monitored_session.ChiefSessionCreator(
scaffold=scaffold,
checkpoint_filename_with_path=checkpoint_path,
master='',
config=None)
im_features_size = config['im_features_size']
rnn_size = config['rnn_size']
dense_mean = np.zeros((im_features_size + rnn_size))
with monitored_session.MonitoredSession( # Generate queue
session_creator=session_creator, hooks=None) as session:
batch_size = config['batch_size']
nb_batches = model.dataset.num_samples / batch_size
for i in range(nb_batches):
current_dense = session.run(model.concat_features)
weight = float(i) * batch_size / ((i + 1) * batch_size)
dense_mean = weight * dense_mean + (
1 - weight) * current_dense.mean(axis=0)
# Now look at outliers
max_norms = np.zeros((batch_size))
max_post_ids = np.zeros((batch_size))
max_logits = np.zeros((batch_size, model.dataset.num_classes))
for i in range(nb_batches):
current_dense, np_post_ids, current_logits = session.run(
[model.concat_features, model.post_ids, model.logits])
current_diff = np.linalg.norm(current_dense - dense_mean,
axis=1)
for k in range(batch_size):
if current_diff[k] > max_norms[k]:
max_norms[k] = current_diff[k]
max_post_ids[k] = np_post_ids[k]
max_logits[k] = current_logits[k]
np.save('data/max_norms.npy', max_norms)
np.save('data/max_post_ids.npy', max_post_ids)
np.save('data/max_logits.npy', max_logits)
return max_norms, max_post_ids, max_logits
def test_get_sequence_dense_tensor(self):
vocabulary_size = 3
sparse_input = sparse_tensor.SparseTensorValue(
# example 0, ids [2]
# example 1, ids [0, 1]
# example 2, ids []
# example 3, ids [1]
indices=((0, 0), (1, 0), (1, 1), (3, 0)),
values=(2, 0, 1, 1),
dense_shape=(4, 2))
embedding_dimension = 2
embedding_values = (
(1., 2.), # id 0
(3., 5.), # id 1
(7., 11.) # id 2
)
def _initializer(shape, dtype, partition_info):
self.assertAllEqual((vocabulary_size, embedding_dimension), shape)
self.assertEqual(dtypes.float32, dtype)
self.assertIsNone(partition_info)
return embedding_values
expected_lookups = [
# example 0, ids [2]
[[7., 11.], [0., 0.]],
# example 1, ids [0, 1]
[[1., 2.], [3., 5.]],
# example 2, ids []
[[0., 0.], [0., 0.]],
# example 3, ids [1]
[[3., 5.], [0., 0.]],
]
categorical_column = sfc.sequence_categorical_column_with_identity(
key='aaa', num_buckets=vocabulary_size)
embedding_column = sfc._sequence_embedding_column(
categorical_column,
dimension=embedding_dimension,
initializer=_initializer)
embedding_lookup, _ = embedding_column._get_sequence_dense_tensor(
_LazyBuilder({'aaa': sparse_input}))
global_vars = ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES)
self.assertItemsEqual(('embedding_weights:0', ),
tuple([v.name for v in global_vars]))
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(embedding_values,
global_vars[0].eval(session=sess))
self.assertAllEqual(expected_lookups,
embedding_lookup.eval(session=sess))
def run(checkpoint, batch_size, dataset_name, images_data, labels):
images_placeholder, labels_placeholder, endpoints = create_model(
batch_size, dataset_name)
session_creator = monitored_session.ChiefSessionCreator(
checkpoint_filename_with_path=checkpoint)
with monitored_session.MonitoredSession(
session_creator=session_creator) as sess:
prob = sess.run(endpoints,
feed_dict={
images_placeholder: images_data,
labels_placeholder: labels
})
return prob
def testStartQueueRunnersIgnoresMonitoredSession(self):
zero64 = constant_op.constant(0, dtype=dtypes.int64)
var = variables.VariableV1(zero64)
count_up_to = var.count_up_to(3)
queue = data_flow_ops.FIFOQueue(10, dtypes.float32)
init_op = variables.global_variables_initializer()
qr = queue_runner_impl.QueueRunner(queue, [count_up_to])
queue_runner_impl.add_queue_runner(qr)
with self.cached_session():
init_op.run()
threads = queue_runner_impl.start_queue_runners(
monitored_session.MonitoredSession())
self.assertFalse(threads)
def test_sequence_length_with_zeros(self):
column = sfc.sequence_categorical_column_with_identity(
'aaa', num_buckets=3)
inputs = sparse_tensor.SparseTensorValue(
indices=((1, 0), (3, 0), (3, 1)),
values=(1, 2, 0),
dense_shape=(5, 2))
expected_sequence_length = [0, 1, 0, 2, 0]
sequence_length = column._sequence_length(_LazyBuilder({'aaa': inputs}))
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(
expected_sequence_length, sequence_length.eval(session=sess))
def run(checkpoint, batch_size, dataset_name, image_path_pattern):
images_placeholder, endpoints = create_model(batch_size, dataset_name)
images_data, paths = load_images(image_path_pattern, batch_size,
dataset_name)
session_creator = monitored_session.ChiefSessionCreator(
checkpoint_filename_with_path=checkpoint)
import time
stime = time.time()
with monitored_session.MonitoredSession(
session_creator=session_creator) as sess:
predictions = sess.run(endpoints.predicted_text,
feed_dict={images_placeholder: images_data})
print('Running time: ', time.time() - stime)
return predictions.tolist(), paths
def test_sequence_length_with_empty_rows(self):
"""Tests _sequence_length when some examples do not have ids."""
vocabulary_size = 3
sparse_input_a = sparse_tensor.SparseTensorValue(
# example 0, ids []
# example 1, ids [2]
# example 2, ids [0, 1]
# example 3, ids []
# example 4, ids [1]
# example 5, ids []
indices=((1, 0), (2, 0), (2, 1), (4, 0)),
values=(2, 0, 1, 1),
dense_shape=(6, 2))
expected_sequence_length_a = [0, 1, 2, 0, 1, 0]
categorical_column_a = sfc.sequence_categorical_column_with_identity(
key='aaa', num_buckets=vocabulary_size)
sparse_input_b = sparse_tensor.SparseTensorValue(
# example 0, ids [2]
# example 1, ids []
# example 2, ids []
# example 3, ids []
# example 4, ids [1]
# example 5, ids [0, 1]
indices=((0, 0), (4, 0), (5, 0), (5, 1)),
values=(2, 1, 0, 1),
dense_shape=(6, 2))
expected_sequence_length_b = [1, 0, 0, 0, 1, 2]
categorical_column_b = sfc.sequence_categorical_column_with_identity(
key='bbb', num_buckets=vocabulary_size)
shared_embedding_columns = fc.shared_embedding_columns(
[categorical_column_a, categorical_column_b], dimension=2)
sequence_length_a = shared_embedding_columns[0]._get_sequence_dense_tensor(
_LazyBuilder({
'aaa': sparse_input_a
}))[1]
sequence_length_b = shared_embedding_columns[1]._get_sequence_dense_tensor(
_LazyBuilder({
'bbb': sparse_input_b
}))[1]
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(
expected_sequence_length_a, sequence_length_a.eval(session=sess))
self.assertAllEqual(
expected_sequence_length_b, sequence_length_b.eval(session=sess))
def test_sequence_length(self):
column = sfc.sequence_categorical_column_with_vocabulary_list(
key='aaa', vocabulary_list=('omar', 'stringer', 'marlo'))
inputs = sparse_tensor.SparseTensorValue(indices=((0, 0), (1, 0), (1,
1)),
values=('marlo', 'skywalker',
'omar'),
dense_shape=(2, 2))
expected_sequence_length = [1, 2]
sequence_length = column._sequence_length(_LazyBuilder({'aaa':
inputs}))
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(expected_sequence_length,
sequence_length.eval(session=sess))
def test_sequence_length(self):
column = sfc.sequence_categorical_column_with_identity('aaa',
num_buckets=3)
inputs = sparse_tensor.SparseTensorValue(indices=((0, 0), (1, 0), (1,
1)),
values=(1, 2, 0),
dense_shape=(2, 2))
expected_sequence_length = [1, 2]
sequence_length = column._sequence_length(_LazyBuilder({'aaa':
inputs}))
with monitored_session.MonitoredSession() as sess:
sequence_length = sess.run(sequence_length)
self.assertAllEqual(expected_sequence_length, sequence_length)
self.assertEqual(np.int64, sequence_length.dtype)
def day_of_week_trend(checkpoint_dir):
"""Compute day of week trend.
Parameters:
checkpoint_dir: Checkpoint of the saved model during training.
"""
with tf.Graph().as_default():
config = _CONFIG.copy()
config['mode'] = 'validation'
model = DeepSentiment(config)
# Load model
checkpoint_path = tf_saver.latest_checkpoint(checkpoint_dir)
scaffold = monitored_session.Scaffold(init_op=None,
init_feed_dict=None,
init_fn=None,
saver=None)
session_creator = monitored_session.ChiefSessionCreator(
scaffold=scaffold,
checkpoint_filename_with_path=checkpoint_path,
master='',
config=None)
posts_logits = []
posts_labels = []
posts_days = []
posts_ids = []
with monitored_session.MonitoredSession( # Generate queue
session_creator=session_creator, hooks=None) as session:
batch_size = config['batch_size']
nb_batches = model.dataset.num_samples / batch_size
for i in range(nb_batches):
np_logits, np_labels, np_days, np_post_ids = session.run(
[model.logits, model.labels, model.days, model.post_ids])
posts_logits.append(np_logits)
posts_labels.append(np_labels)
posts_days.append(np_days)
posts_ids.append(np_post_ids)
posts_logits, posts_labels = np.vstack(posts_logits), np.hstack(
posts_labels)
posts_days, posts_ids = np.hstack(posts_days), np.hstack(posts_ids)
np.save('data/posts_logits_week.npy', posts_logits)
np.save('data/posts_labels_week.npy', posts_labels)
np.save('data/posts_days_week.npy', posts_days)
np.save('data/posts_ids_week.npy', posts_ids)
return posts_logits, posts_labels, posts_days, posts_ids
def _predict(self, run_ctx, step):
var_name_to_value = run_ctx.session.run(self._var_name_to_train_var)
logging.info('Building placeholders.')
placeholder_to_value = {
self._var_name_to_placeholder[v_name]: var_name_to_value[v_name]
for v_name in var_name_to_value
}
def feed_variables(scaffold, session):
del scaffold
session.run(self._var_feed_op, feed_dict=placeholder_to_value)
logging.info('Building scaffold.')
scaffold = training.Scaffold(init_fn=feed_variables)
with self._graph.as_default():
session_creator = monitored_session.ChiefSessionCreator(
scaffold=scaffold,
checkpoint_filename_with_path=None,
master=run_ctx.session.sess_str)
self._handler.setup(step)
logging.info('Setup done.')
with monitored_session.MonitoredSession(
session_creator=session_creator,
hooks=self._all_hooks) as predict_session:
while not predict_session.should_stop():
logging.info('Predicting.... %s', self._predictions)
preds_evaluated = predict_session.run(self._predictions)
if not isinstance(self._predictions, dict):
for pred in preds_evaluated:
self._handler.handle_prediction(pred)
else:
for i in range(
self._estimator._extract_batch_length(
preds_evaluated)):
self._handler.handle_prediction({
key: value[i]
for key, value in six.iteritems(
preds_evaluated)
})
logging.info('Finalizing.')
self._handler.finalize(step)
logging.info('Done with prediction.')
self._timer.update_last_triggered_step(step)
def __init__(self,
estimator,
prediction_input_fn,
input_alternative_key=None,
output_alternative_key=None,
graph=None,
config=None):
"""Initialize a `ContribEstimatorPredictor`.
Args:
estimator: an instance of `tf.contrib.learn.Estimator`.
prediction_input_fn: a function that takes no arguments and returns an
instance of `InputFnOps`.
input_alternative_key: Optional. Specify the input alternative used for
prediction.
output_alternative_key: Specify the output alternative used for
prediction. Not needed for single-headed models but required for
multi-headed models.
graph: Optional. The Tensorflow `graph` in which prediction should be
done.
config: `ConfigProto` proto used to configure the session.
"""
self._graph = graph or ops.Graph()
with self._graph.as_default():
input_fn_ops = prediction_input_fn()
# pylint: disable=protected-access
model_fn_ops = estimator._get_predict_ops(input_fn_ops.features)
# pylint: enable=protected-access
checkpoint_path = checkpoint_management.latest_checkpoint(
estimator.model_dir)
self._session = monitored_session.MonitoredSession(
session_creator=monitored_session.ChiefSessionCreator(
config=config,
checkpoint_filename_with_path=checkpoint_path))
input_alternative_key = (
input_alternative_key
or saved_model_export_utils.DEFAULT_INPUT_ALTERNATIVE_KEY)
input_alternatives, _ = saved_model_export_utils.get_input_alternatives(
input_fn_ops)
self._feed_tensors = input_alternatives[input_alternative_key]
(output_alternatives, output_alternative_key
) = saved_model_export_utils.get_output_alternatives(
model_fn_ops, output_alternative_key)
_, fetch_tensors = output_alternatives[output_alternative_key]
self._fetch_tensors = fetch_tensors
def test_sequence_length_with_shape(self):
"""Tests _sequence_length with shape !=(1,)."""
sparse_input = sparse_tensor.SparseTensorValue(
# example 0, values [[0.], [1]]
# example 1, [[10.]]
indices=((0, 0), (0, 1), (1, 0)),
values=(0., 1., 10.),
dense_shape=(2, 2))
expected_sequence_length = [2, 1]
numeric_column = sfc.sequence_numeric_column('aaa')
_, sequence_length = numeric_column._get_sequence_dense_tensor(
_LazyBuilder({'aaa': sparse_input}))
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(expected_sequence_length,
sequence_length.eval(session=sess))
def main():
height, width, channel = get_dataset_image_shape(FLAGS.dataset_name)
images_placeholder, endpoints = create_model(FLAGS.dataset_name)
session_creator = monitored_session.ChiefSessionCreator(
checkpoint_filename_with_path=
'/media/dont/data/dont/datasets/crnn/tfname/logs/model.ckpt-110665')
image = PIL.Image.open(sys.argv[1]).convert('RGB')
#image = image.resize((width, height), PIL.Image.ANTIALIAS)
images_data = np.expand_dims(np.asarray(image), axis=0)
sess = monitored_session.MonitoredSession(session_creator=session_creator)
start = timeit.default_timer()
predictions = sess.run(endpoints.predicted_text,
feed_dict={images_placeholder: images_data})
print(predictions[0].decode('utf8'))
stop = timeit.default_timer()
print('Time : ', stop - start)
def test_sequence_length(self):
sparse_input = sparse_tensor.SparseTensorValue(
# example 0, values [[0., 1., 2.], [3., 4., 5.]]
# example 1, [[10., 11., 12.]]
indices=((0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0),
(1, 1), (1, 2)),
values=(0., 1., 2., 3., 4., 5., 10., 11., 12.),
dense_shape=(2, 6))
expected_sequence_length = [2, 1]
numeric_column = sfc.sequence_numeric_column('aaa', shape=(3, ))
_, sequence_length = numeric_column._get_sequence_dense_tensor(
_LazyBuilder({'aaa': sparse_input}))
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual(expected_sequence_length,
sequence_length.eval(session=sess))
def test_table_in_graph(self, cycles):
root = self._make_model_with_tables()
if cycles > 1:
root = self.cycle(root, cycles - 1)
path = tempfile.mkdtemp(prefix=self.get_temp_dir())
save.save(root, path)
imported = self.cycle(root, 1)
with ops.Graph().as_default():
imported = load.load(path)
keys = constant_op.constant(["brain", "test", "foo", "surgery"])
output1 = imported.lookup1(keys)
output2 = imported.lookup2(keys)
with monitored_session.MonitoredSession() as sess:
self.assertAllEqual([0, -1, -1, 2], sess.run(output1))
self.assertAllEqual([2, 0, 1, -1], sess.run(output2))
def test_get_sparse_tensors_inputs3d(self):
"""Tests _get_sparse_tensors when the input is already 3D Tensor."""
column = sfc.sequence_categorical_column_with_identity('aaa',
num_buckets=3)
inputs = sparse_tensor.SparseTensorValue(indices=((0, 0, 0), (1, 0, 0),
(1, 1, 0)),
values=(1, 2, 0),
dense_shape=(2, 2, 1))
with self.assertRaisesRegexp(
errors.InvalidArgumentError,
r'Column aaa expected ID tensor of rank 2\.\s*'
r'id_tensor shape:\s*\[2 2 1\]'):
id_weight_pair = column._get_sparse_tensors(
_LazyBuilder({'aaa': inputs}))
with monitored_session.MonitoredSession() as sess:
id_weight_pair.id_tensor.eval(session=sess)
