def testNewStyleAudioSummary(self):
"""Verify processing of tensorboard.plugins.audio.summary."""
event_sink = _EventGenerator(self, zero_out_timestamps=True)
writer = tf.summary.FileWriter(self.get_temp_dir())
writer.event_writer = event_sink
with self.test_session() as sess:
ipt = tf.random_normal(shape=[5, 441, 2])
with tf.name_scope('1'):
audio_summary.op('one', ipt, sample_rate=44100, max_outputs=1)
with tf.name_scope('2'):
audio_summary.op('two', ipt, sample_rate=44100, max_outputs=2)
with tf.name_scope('3'):
audio_summary.op('three', ipt, sample_rate=44100, max_outputs=3)
merged = tf.summary.merge_all()
writer.add_graph(sess.graph)
for i in xrange(10):
summ = sess.run(merged)
writer.add_summary(summ, global_step=i)
accumulator = ea.EventAccumulator(event_sink)
accumulator.Reload()
tags = [
u'1/one/audio_summary',
u'2/two/audio_summary',
u'3/three/audio_summary',
]
self.assertTagsEqual(accumulator.Tags(), {
ea.TENSORS: tags,
ea.GRAPH: True,
ea.META_GRAPH: False,
})
def test_new_style_histogram(self):
op = histogram_summary.op('important_data',
tf.random_normal(shape=[10, 10]),
bucket_count=100,
display_name='Important data',
description='secrets of the universe')
value = self._value_from_op(op)
assert value.HasField('tensor'), value
self._assert_noop(value)
def test_new_style_image(self):
op = image_summary.op(
'mona_lisa',
tf.image.convert_image_dtype(
tf.random_normal(shape=[1, 400, 200, 3]), tf.uint8, saturate=True),
display_name='The Mona Lisa',
description='A renowned portrait by da Vinci.')
value = self._value_from_op(op)
assert value.HasField('tensor'), value
self._assert_noop(value)
def test_histogram(self):
old_op = tf.summary.histogram('important_data',
tf.random_normal(shape=[23, 45]))
old_value = self._value_from_op(old_op)
assert old_value.HasField('histo'), old_value
new_value = data_compat.migrate_value(old_value)
self.assertEqual('important_data', new_value.tag)
expected_metadata = histogram_metadata.create_summary_metadata(
display_name='important_data', description='')
self.assertEqual(expected_metadata, new_value.metadata)
self.assertTrue(new_value.HasField('tensor'))
buckets = tf.make_ndarray(new_value.tensor)
self.assertEqual(old_value.histo.min, buckets[0][0])
self.assertEqual(old_value.histo.max, buckets[-1][1])
self.assertEqual(23 * 45, buckets[:, 2].astype(int).sum())
def test_image(self):
old_op = tf.summary.image('mona_lisa',
tf.image.convert_image_dtype(
tf.random_normal(shape=[1, 400, 200, 3]),
tf.uint8,
saturate=True))
old_value = self._value_from_op(old_op)
assert old_value.HasField('image'), old_value
new_value = data_compat.migrate_value(old_value)
self.assertEqual('mona_lisa/image/0', new_value.tag)
expected_metadata = image_metadata.create_summary_metadata(
display_name='mona_lisa/image/0', description='')
self.assertEqual(expected_metadata, new_value.metadata)
self.assertTrue(new_value.HasField('tensor'))
(width, height, data) = tf.make_ndarray(new_value.tensor)
self.assertEqual(b'200', width)
self.assertEqual(b'400', height)
self.assertEqual(
tf.compat.as_bytes(old_value.image.encoded_image_string), data)
def run_all(logdir, verbose=False):
"""Generate a bunch of histogram data, and write it to logdir."""
del verbose
tf.set_random_seed(0)
k = tf.placeholder(tf.float32)
# Make a normal distribution, with a shifting mean
mean_moving_normal = tf.random_normal(shape=[1000], mean=(5*k), stddev=1)
# Record that distribution into a histogram summary
histogram_summary.op("normal/moving_mean",
mean_moving_normal,
description="A normal distribution whose mean changes "
"over time.")
# Make a normal distribution with shrinking variance
shrinking_normal = tf.random_normal(shape=[1000], mean=0, stddev=1-(k))
# Record that distribution too
histogram_summary.op("normal/shrinking_variance", shrinking_normal,
description="A normal distribution whose variance "
"shrinks over time.")
# Let's combine both of those distributions into one dataset
normal_combined = tf.concat([mean_moving_normal, shrinking_normal], 0)
# We add another histogram summary to record the combined distribution
histogram_summary.op("normal/bimodal", normal_combined,
description="A combination of two normal distributions, "
"one with a moving mean and one with "
"shrinking variance. The result is a "
"distribution that starts as unimodal and "
"becomes more and more bimodal over time.")
# Add a gamma distribution
gamma = tf.random_gamma(shape=[1000], alpha=k)
histogram_summary.op("gamma", gamma,
description="A gamma distribution whose shape "
"parameter, α, changes over time.")
# And a poisson distribution
poisson = tf.random_poisson(shape=[1000], lam=k)
histogram_summary.op("poisson", poisson,
description="A Poisson distribution, which only "
"takes on integer values.")
# And a uniform distribution
uniform = tf.random_uniform(shape=[1000], maxval=k*10)
histogram_summary.op("uniform", uniform,
description="A simple uniform distribution.")
# Finally, combine everything together!
all_distributions = [mean_moving_normal, shrinking_normal,
gamma, poisson, uniform]
all_combined = tf.concat(all_distributions, 0)
histogram_summary.op("all_combined", all_combined,
description="An amalgamation of five distributions: a "
"uniform distribution, a gamma "
"distribution, a Poisson distribution, and "
"two normal distributions.")
summaries = tf.summary.merge_all()
# Setup a session and summary writer
sess = tf.Session()
writer = tf.summary.FileWriter(logdir)
# Setup a loop and write the summaries to disk
N = 400
for step in xrange(N):
k_val = step/float(N)
summ = sess.run(summaries, feed_dict={k: k_val})
writer.add_summary(summ, global_step=step)
def run(logdir, session_id, hparams, group_name):
"""Runs a temperature simulation.
This will simulate an object at temperature `initial_temperature`
sitting at rest in a large room at temperature `ambient_temperature`.
The object has some intrinsic `heat_coefficient`, which indicates
how much thermal conductivity it has: for instance, metals have high
thermal conductivity, while the thermal conductivity of water is low.
Over time, the object's temperature will adjust to match the
temperature of its environment. We'll track the object's temperature,
how far it is from the room's temperature, and how much it changes at
each time step.
Arguments:
logdir: the top-level directory into which to write summary data
session_id: an id for the session.
hparams: A dictionary mapping an hyperparameter name to its value.
group_name: an id for the session group this session belongs to.
"""
tf.reset_default_graph()
tf.set_random_seed(0)
initial_temperature = hparams['initial_temperature']
ambient_temperature = hparams['ambient_temperature']
heat_coefficient = hparams['heat_coefficient']
session_dir = os.path.join(logdir, session_id)
writer = tf.summary.FileWriter(session_dir)
writer.add_summary(
summary.session_start_pb(hparams=hparams, group_name=group_name))
writer.flush()
with tf.name_scope('temperature'):
# Create a mutable variable to hold the object's temperature, and
# create a scalar summary to track its value over time. The name of
# the summary will appear as "temperature/current" due to the
# name-scope above.
temperature = tf.Variable(tf.constant(initial_temperature),
name='temperature')
scalar_summary.op('current',
temperature,
display_name='Temperature',
description='The temperature of the object under '
'simulation, in Kelvins.')
# Compute how much the object's temperature differs from that of its
# environment, and track this, too: likewise, as
# "temperature/difference_to_ambient".
ambient_difference = temperature - ambient_temperature
scalar_summary.op(
'difference_to_ambient',
ambient_difference,
display_name='Difference to ambient temperature',
description=('The difference between the ambient '
'temperature and the temperature of the '
'object under simulation, in Kelvins.'))
# Newton suggested that the rate of change of the temperature of an
# object is directly proportional to this `ambient_difference` above,
# where the proportionality constant is what we called the heat
# coefficient. But in real life, not everything is quite so clean, so
# we'll add in some noise. (The value of 50 is arbitrary, chosen to
# make the data look somewhat interesting. :-) )
noise = 50 * tf.random_normal([])
delta = -heat_coefficient * (ambient_difference + noise)
scalar_summary.op(
'delta',
delta,
description='The change in temperature from the previous '
'step, in Kelvins.')
# Collect all the scalars that we want to keep track of.
summ = tf.summary.merge_all()
# Now, augment the current temperature by this delta that we computed,
# blocking the assignment on summary collection to avoid race conditions
# and ensure that the summary always reports the pre-update value.
with tf.control_dependencies([summ]):
update_step = temperature.assign_add(delta)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
for step in xrange(STEPS):
# By asking TensorFlow to compute the update step, we force it to
# change the value of the temperature variable. We don't actually
# care about this value, so we discard it; instead, we grab the
# summary data computed along the way.
(s, _) = sess.run([summ, update_step])
writer.add_summary(s, global_step=step)
writer.add_summary(summary.session_end_pb(api_pb2.STATUS_SUCCESS))
writer.close()