def initialize_graph(self): self._audio_placeholder = tf.placeholder(dtype=tf.float32, name='image_to_encode') self._samples_per_second_placeholder = tf.placeholder( dtype=tf.int32, name='samples_per_second') self._encode_op = tf.contrib.ffmpeg.encode_audio( self._audio_placeholder, file_format='wav', samples_per_second=self._samples_per_second_placeholder)
def setUp(self): self.log_dir = tempfile.mkdtemp() # We use numpy.random to generate images. We seed to avoid non-determinism # in this test. numpy.random.seed(42) # Create old-style image summaries for run "foo". tf.reset_default_graph() sess = tf.Session() placeholder = tf.placeholder(tf.uint8) tf.summary.image(name="baz", tensor=placeholder) merged_summary_op = tf.summary.merge_all() foo_directory = os.path.join(self.log_dir, "foo") writer = tf.summary.FileWriter(foo_directory) writer.add_graph(sess.graph) for step in xrange(2): writer.add_summary(sess.run(merged_summary_op, feed_dict={ placeholder: (numpy.random.rand(1, 16, 42, 3) * 255).astype( numpy.uint8) }), global_step=step) writer.close() # Create new-style image summaries for run bar. tf.reset_default_graph() sess = tf.Session() placeholder = tf.placeholder(tf.uint8) summary.op(name="quux", images=placeholder, description="how do you pronounce that, anyway?") merged_summary_op = tf.summary.merge_all() bar_directory = os.path.join(self.log_dir, "bar") writer = tf.summary.FileWriter(bar_directory) writer.add_graph(sess.graph) for step in xrange(2): writer.add_summary(sess.run(merged_summary_op, feed_dict={ placeholder: (numpy.random.rand(1, 8, 6, 3) * 255).astype( numpy.uint8) }), global_step=step) writer.close() # Start a server with the plugin. multiplexer = event_multiplexer.EventMultiplexer({ "foo": foo_directory, "bar": bar_directory, }) context = base_plugin.TBContext( logdir=self.log_dir, multiplexer=multiplexer) plugin = images_plugin.ImagesPlugin(context) # Setting a reload interval of -1 disables reloading. We disable reloading # because we seek to block tests from running til after one reload finishes. # This setUp method thus manually reloads the multiplexer. TensorBoard would # otherwise reload in a non-blocking thread. wsgi_app = application.TensorBoardWSGIApp( self.log_dir, [plugin], multiplexer, reload_interval=-1, path_prefix='') self.server = werkzeug_test.Client(wsgi_app, wrappers.BaseResponse) multiplexer.Reload() self.routes = plugin.get_plugin_apps()
def testNewStyleScalarSummary(self): """Verify processing of tensorboard.plugins.scalar.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: step = tf.placeholder(tf.float32, shape=[]) scalar_summary.op('accuracy', 1.0 - 1.0 / (step + tf.constant(1.0))) scalar_summary.op('xent', 1.0 / (step + tf.constant(1.0))) merged = tf.summary.merge_all() writer.add_graph(sess.graph) for i in xrange(10): summ = sess.run(merged, feed_dict={step: float(i)}) writer.add_summary(summ, global_step=i) accumulator = ea.EventAccumulator(event_sink) accumulator.Reload() tags = [ u'accuracy/scalar_summary', u'xent/scalar_summary', ] self.assertTagsEqual(accumulator.Tags(), { ea.TENSORS: tags, ea.GRAPH: True, ea.META_GRAPH: False, })
def generate_testdata(self, include_text=True, logdir=None): tf.reset_default_graph() sess = tf.Session() placeholder = tf.placeholder(tf.string) summary_tensor = tf.summary.text('message', placeholder) vector_summary = tf.summary.text('vector', placeholder) scalar_summary = tf.summary.scalar('twelve', tf.constant(12)) run_names = ['fry', 'leela'] for run_name in run_names: subdir = os.path.join(logdir or self.logdir, run_name) writer = tf.summary.FileWriter(subdir) writer.add_graph(sess.graph) step = 0 for gem in GEMS: message = run_name + ' *loves* ' + gem feed_dict = { placeholder: message, } if include_text: summ = sess.run(summary_tensor, feed_dict=feed_dict) writer.add_summary(summ, global_step=step) step += 1 vector_message = ['one', 'two', 'three', 'four'] if include_text: summ = sess.run(vector_summary, feed_dict={placeholder: vector_message}) writer.add_summary(summ) summ = sess.run(scalar_summary, feed_dict={placeholder: []}) writer.add_summary(summ) writer.close()
def generate_run(self, run_name): tf.reset_default_graph() sess = tf.Session() placeholder = tf.placeholder(tf.float32, shape=[3]) if run_name == self._RUN_WITH_LEGACY_HISTOGRAM: tf.summary.histogram(self._LEGACY_HISTOGRAM_TAG, placeholder) elif run_name == self._RUN_WITH_HISTOGRAM: summary.op(self._HISTOGRAM_TAG, placeholder, display_name=self._DISPLAY_NAME, description=self._DESCRIPTION) elif run_name == self._RUN_WITH_SCALARS: tf.summary.scalar(self._SCALAR_TAG, tf.reduce_mean(placeholder)) else: assert False, 'Invalid run name: %r' % run_name summ = tf.summary.merge_all() subdir = os.path.join(self.logdir, run_name) writer = tf.summary.FileWriter(subdir) writer.add_graph(sess.graph) for step in xrange(self._STEPS): feed_dict = {placeholder: [1 + step, 2 + step, 3 + step]} s = sess.run(summ, feed_dict=feed_dict) writer.add_summary(s, global_step=step) writer.close()
def WriteAudioSeries(writer, tag, n_audio=1): """Write a few dummy audio clips to writer.""" step = 0 session = tf.Session() min_frequency_hz = 440 max_frequency_hz = 880 sample_rate = 4000 duration_frames = sample_rate // 2 # 0.5 seconds. frequencies_per_run = 1 num_channels = 2 p = tf.placeholder("float32", (frequencies_per_run, duration_frames, num_channels)) s = tf.summary.audio(tag, p, sample_rate) for _ in xrange(n_audio): # Generate a different frequency for each channel to show stereo works. frequencies = np.random.random_integers(min_frequency_hz, max_frequency_hz, size=(frequencies_per_run, num_channels)) tiled_frequencies = np.tile(frequencies, (1, duration_frames)) tiled_increments = np.tile(np.arange(0, duration_frames), (num_channels, 1)).T.reshape( 1, duration_frames * num_channels) tones = np.sin(2.0 * np.pi * tiled_frequencies * tiled_increments / sample_rate) tones = tones.reshape(frequencies_per_run, duration_frames, num_channels) summ = session.run(s, feed_dict={p: tones}) writer.add_summary(summ, step) step += 20 session.close()
def test_when_bucket_count_not_statically_known(self): placeholder = tf.placeholder(tf.int32, shape=()) bucket_count = 44 pb = self.compute_and_check_summary_pb( bucket_count=bucket_count, bucket_count_tensor=placeholder, feed_dict={placeholder: bucket_count}) buckets = tf.make_ndarray(pb.value[0].tensor) self.assertEqual(buckets.shape, (bucket_count, 3))
def WriteImageSeries(writer, tag, n_images=1): """Write a few dummy images to writer.""" step = 0 session = tf.Session() p = tf.placeholder("uint8", (1, 4, 4, 3)) s = tf.summary.image(tag, p) for _ in xrange(n_images): im = np.random.random_integers(0, 255, (1, 4, 4, 3)) summ = session.run(s, feed_dict={p: im}) writer.add_summary(summ, step) step += 20 session.close()
def _test_dimensions(self, alpha=False, static_dimensions=True): if not alpha: images = self.images channel_count = 3 else: images = self.images_with_alpha channel_count = 4 if static_dimensions: images_tensor = tf.constant(images, dtype=tf.uint8) feed_dict = {} else: images_tensor = tf.placeholder(tf.uint8) feed_dict = {images_tensor: images} pb = self.compute_and_check_summary_pb('mona_lisa', images, images_tensor=images_tensor, feed_dict=feed_dict) self.assertEqual(1, len(pb.value)) result = pb.value[0].tensor.string_val # Check annotated dimensions. self.assertEqual(tf.compat.as_bytes(str(self.image_width)), result[0]) self.assertEqual(tf.compat.as_bytes(str(self.image_height)), result[1]) # Check actual image dimensions. images = result[2:] with tf.Session() as sess: placeholder = tf.placeholder(tf.string) decoder = tf.image.decode_png(placeholder) for image in images: decoded = sess.run(decoder, feed_dict={placeholder: image}) self.assertEqual( (self.image_height, self.image_width, channel_count), decoded.shape)
def run_all(logdir): tf.reset_default_graph() step_placeholder = tf.placeholder(tf.int32) with tf.name_scope('simple_example'): simple_example(step_placeholder) with tf.name_scope('markdown_table'): markdown_table(step_placeholder) with tf.name_scope('higher_order_tensors'): higher_order_tensors(step_placeholder) all_summaries = tf.summary.merge_all() with tf.Session() as sess: writer = tf.summary.FileWriter(logdir) writer.add_graph(sess.graph) for step in xrange(STEPS): s = sess.run(all_summaries, feed_dict={step_placeholder: step}) writer.add_summary(s, global_step=step) writer.close()
def _get_writer_fn(self, event_batch): key = (event_batch.experiment_name, event_batch.run_name) if key in self._writer_fn_cache: return self._writer_fn_cache[key] with tf.Graph().as_default(): placeholder = tf.placeholder(shape=[], dtype=tf.string) writer = tf.contrib.summary.create_db_writer( self._db_path, experiment_name=event_batch.experiment_name, run_name=event_batch.run_name) with writer.as_default(): # TODO(nickfelt): running import_event() one record at a time is very # slow; we should add an op that accepts a vector of records. import_op = tf.contrib.summary.import_event(placeholder) session = tf.Session() session.run(writer.init()) def writer_fn(event_proto): session.run(import_op, feed_dict={placeholder: event_proto}) self._writer_fn_cache[key] = writer_fn return writer_fn
def generate_run_to_db(self, experiment_name, run_name): tf.reset_default_graph() global_step = tf.placeholder(tf.int64) db_writer = tf.contrib.summary.create_db_writer( db_uri=self.db_path, experiment_name=experiment_name, run_name=run_name, user_name='user') scalar_ops = None with db_writer.as_default( ), tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar(self._SCALAR_TAG, 42, step=global_step) flush_op = tf.contrib.summary.flush(db_writer._resource) with tf.Session() as sess: sess.run(tf.contrib.summary.summary_writer_initializer_op()) for step in xrange(self._STEPS): feed_dict = {global_step: step} sess.run(tf.contrib.summary.all_summary_ops(), feed_dict=feed_dict) sess.run(flush_op)
def testTFSummaryScalar(self): """Verify processing of tf.summary.scalar.""" 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.placeholder(tf.float32) tf.summary.scalar('scalar1', ipt) tf.summary.scalar('scalar2', ipt * ipt) merged = tf.summary.merge_all() writer.add_graph(sess.graph) for i in xrange(10): summ = sess.run(merged, feed_dict={ipt: i}) writer.add_summary(summ, global_step=i) accumulator = ea.EventAccumulator(event_sink) accumulator.Reload() seq1 = [ ea.ScalarEvent(wall_time=0, step=i, value=i) for i in xrange(10) ] seq2 = [ ea.ScalarEvent(wall_time=0, step=i, value=i * i) for i in xrange(10) ] self.assertTagsEqual( accumulator.Tags(), { ea.SCALARS: ['scalar1', 'scalar2'], ea.GRAPH: True, ea.META_GRAPH: False, }) self.assertEqual(accumulator.Scalars('scalar1'), seq1) self.assertEqual(accumulator.Scalars('scalar2'), seq2) first_value = accumulator.Scalars('scalar1')[0].value self.assertTrue(isinstance(first_value, float))
def run(logdir, run_name, wave_name, wave_constructor): """Generate wave data of the given form. The provided function `wave_constructor` should accept a scalar tensor of type float32, representing the frequency (in Hz) at which to construct a wave, and return a tensor of shape [1, _samples(), `n`] representing audio data (for some number of channels `n`). Waves will be generated at frequencies ranging from A4 to A5. Arguments: logdir: the top-level directory into which to write summary data run_name: the name of this run; will be created as a subdirectory under logdir wave_name: the name of the wave being generated wave_constructor: see above """ tf.reset_default_graph() tf.set_random_seed(0) # On each step `i`, we'll set this placeholder to `i`. This allows us # to know "what time it is" at each step. step_placeholder = tf.placeholder(tf.float32, shape=[]) # We want to linearly interpolate a frequency between A4 (440 Hz) and # A5 (880 Hz). with tf.name_scope('compute_frequency'): f_min = 440.0 f_max = 880.0 t = step_placeholder / (FLAGS.steps - 1) frequency = f_min * (1.0 - t) + f_max * t # Let's log this frequency, just so that we can make sure that it's as # expected. tf.summary.scalar('frequency', frequency) # Now, we pass this to the wave constructor to get our waveform. Doing # so within a name scope means that any summaries that the wave # constructor produces will be namespaced. with tf.name_scope(wave_name): waveform = wave_constructor(frequency) # We also have the opportunity to annotate each audio clip with a # label. This is a good place to include the frequency, because it'll # be visible immediately next to the audio clip. with tf.name_scope('compute_labels'): samples = tf.shape(waveform)[0] wave_types = tf.tile(["*Wave type:* `%s`." % wave_name], [samples]) frequencies = tf.string_join([ "*Frequency:* ", tf.tile([tf.as_string(frequency, precision=2)], [samples]), " Hz.", ]) samples = tf.string_join([ "*Sample:* ", tf.as_string(tf.range(samples) + 1), " of ", tf.as_string(samples), ".", ]) labels = tf.string_join([wave_types, frequencies, samples], separator=" ") # We can place a description next to the summary in TensorBoard. This # is a good place to explain what the summary represents, methodology # for creating it, etc. Let's include the source code of the function # that generated the wave. source = '\n'.join(' %s' % line.rstrip() for line in inspect.getsourcelines(wave_constructor)[0]) description = ("A wave of type `%r`, generated via:\n\n%s" % (wave_name, source)) # Here's the crucial piece: we interpret this result as audio. summary.op('waveform', waveform, FLAGS.sample_rate, labels=labels, display_name=wave_name, description=description) # Now, we can collect up all the summaries and begin the run. summ = tf.summary.merge_all() sess = tf.Session() writer = tf.summary.FileWriter(os.path.join(logdir, run_name)) writer.add_graph(sess.graph) sess.run(tf.global_variables_initializer()) for step in xrange(FLAGS.steps): s = sess.run(summ, feed_dict={step_placeholder: float(step)}) writer.add_summary(s, global_step=step) writer.close()
def run_sobel(logdir, verbose=False): """Run a Sobel edge detection demonstration. See the summary description for more details. Arguments: logdir: Directory into which to write event logs. verbose: Boolean; whether to log any output. """ if verbose: tf.logging.info('--- Starting run: sobel') tf.reset_default_graph() tf.set_random_seed(0) image = get_image(verbose=verbose) kernel_radius = tf.placeholder(shape=(), dtype=tf.int32) with tf.name_scope('horizontal_kernel'): kernel_side_length = kernel_radius * 2 + 1 # Drop off influence for pixels further away from the center. weighting_kernel = ( 1.0 - tf.abs(tf.linspace(-1.0, 1.0, num=kernel_side_length))) differentiation_kernel = tf.linspace(-1.0, 1.0, num=kernel_side_length) horizontal_kernel = tf.matmul(tf.expand_dims(weighting_kernel, 1), tf.expand_dims(differentiation_kernel, 0)) with tf.name_scope('vertical_kernel'): vertical_kernel = tf.transpose(horizontal_kernel) float_image = tf.cast(image, tf.float32) dx = convolve(float_image, horizontal_kernel, name='convolve_dx') dy = convolve(float_image, vertical_kernel, name='convolve_dy') gradient_magnitude = tf.norm([dx, dy], axis=0, name='gradient_magnitude') with tf.name_scope('normalized_gradient'): normalized_gradient = gradient_magnitude / tf.reduce_max(gradient_magnitude) with tf.name_scope('output_image'): output_image = tf.cast(255 * normalized_gradient, tf.uint8) summ = image_summary.op( 'sobel', tf.stack([output_image]), display_name='Sobel edge detection', description=(u'Demonstration of [Sobel edge detection]. The step ' 'parameter adjusts the radius of the kernel. ' 'The kernel can be of arbitrary size, and considers ' u'nearby pixels with \u2113\u2082-linear falloff.\n\n' # (that says ``$\ell_2$-linear falloff'') 'Edge detection is done on a per-channel basis, so ' 'you can observe which edges are “mostly red ' 'edges,” for instance.\n\n' 'For practical edge detection, a small kernel ' '(usually not more than more than *r*=2) is best.\n\n' '[Sobel edge detection]: %s\n\n' "%s" % ('https://en.wikipedia.org/wiki/Sobel_operator', IMAGE_CREDIT))) with tf.Session() as sess: sess.run(image.initializer) writer = tf.summary.FileWriter(os.path.join(logdir, 'sobel')) writer.add_graph(sess.graph) for step in xrange(8): if verbose: tf.logging.info("--- sobel: step: %s" % step) feed_dict = {kernel_radius: step} run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() s = sess.run(summ, feed_dict=feed_dict, options=run_options, run_metadata=run_metadata) writer.add_summary(s, global_step=step) writer.add_run_metadata(run_metadata, 'step_%04d' % step) writer.close()
def run_box_to_gaussian(logdir, verbose=False): """Run a box-blur-to-Gaussian-blur demonstration. See the summary description for more details. Arguments: logdir: Directory into which to write event logs. verbose: Boolean; whether to log any output. """ if verbose: tf.logging.info('--- Starting run: box_to_gaussian') tf.reset_default_graph() tf.set_random_seed(0) image = get_image(verbose=verbose) blur_radius = tf.placeholder(shape=(), dtype=tf.int32) with tf.name_scope('filter'): blur_side_length = blur_radius * 2 + 1 pixel_filter = tf.ones((blur_side_length, blur_side_length)) pixel_filter = (pixel_filter / tf.cast(tf.size(pixel_filter), tf.float32)) # normalize iterations = 4 images = [tf.cast(image, tf.float32) / 255.0] for _ in xrange(iterations): images.append(convolve(images[-1], pixel_filter)) with tf.name_scope('convert_to_uint8'): images = tf.stack( [tf.cast(255 * tf.clip_by_value(image_, 0.0, 1.0), tf.uint8) for image_ in images]) summ = image_summary.op( 'box_to_gaussian', images, max_outputs=iterations, display_name='Gaussian blur as a limit process of box blurs', description=('Demonstration of forming a Gaussian blur by ' 'composing box blurs, each of which can be expressed ' 'as a 2D convolution.\n\n' 'A Gaussian blur is formed by convolving a Gaussian ' 'kernel over an image. But a Gaussian kernel is ' 'itself the limit of convolving a constant kernel ' 'with itself many times. Thus, while applying ' 'a box-filter convolution just once produces ' 'results that are noticeably different from those ' 'of a Gaussian blur, repeating the same convolution ' 'just a few times causes the result to rapidly ' 'converge to an actual Gaussian blur.\n\n' 'Here, the step value controls the blur radius, ' 'and the image sample controls the number of times ' 'that the convolution is applied (plus one). ' 'So, when *sample*=1, the original image is shown; ' '*sample*=2 shows a box blur; and a hypothetical ' '*sample*=∞ would show a true Gaussian blur.\n\n' 'This is one ingredient in a recipe to compute very ' 'fast Gaussian blurs. The other pieces require ' 'special treatment for the box blurs themselves ' '(decomposition to dual one-dimensional box blurs, ' 'each of which is computed with a sliding window); ' 'we don’t perform those optimizations here.\n\n' '[Here are some slides describing the full process.]' '(%s)\n\n' '%s' % ('http://elynxsdk.free.fr/ext-docs/Blur/Fast_box_blur.pdf', IMAGE_CREDIT))) with tf.Session() as sess: sess.run(image.initializer) writer = tf.summary.FileWriter(os.path.join(logdir, 'box_to_gaussian')) writer.add_graph(sess.graph) for step in xrange(8): if verbose: tf.logging.info('--- box_to_gaussian: step: %s' % step) feed_dict = {blur_radius: step} run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() s = sess.run(summ, feed_dict=feed_dict, options=run_options, run_metadata=run_metadata) writer.add_summary(s, global_step=step) writer.add_run_metadata(run_metadata, 'step_%04d' % step) writer.close()
def run(): """Run custom scalar demo and generate event files.""" step = tf.placeholder(tf.float32, shape=[]) with tf.name_scope('loss'): # Specify 2 different loss values, each tagged differently. summary_lib.scalar('foo', tf.pow(0.9, step)) summary_lib.scalar('bar', tf.pow(0.85, step + 2)) # Log metric baz as well as upper and lower bounds for a margin chart. middle_baz_value = step + 4 * tf.random_uniform([]) - 2 summary_lib.scalar('baz', middle_baz_value) summary_lib.scalar('baz_lower', middle_baz_value - 6.42 - tf.random_uniform([])) summary_lib.scalar('baz_upper', middle_baz_value + 6.42 + tf.random_uniform([])) with tf.name_scope('trigFunctions'): summary_lib.scalar('cosine', tf.cos(step)) summary_lib.scalar('sine', tf.sin(step)) summary_lib.scalar('tangent', tf.tan(step)) merged_summary = tf.summary.merge_all() with tf.Session() as sess, tf.summary.FileWriter(LOGDIR) as writer: # We only need to specify the layout once (instead of per step). layout_summary = summary_lib.custom_scalar_pb( layout_pb2.Layout(category=[ layout_pb2.Category( title='losses', chart=[ layout_pb2.Chart( title='losses', multiline=layout_pb2.MultilineChartContent( tag=[r'loss(?!.*margin.*)'], )), layout_pb2.Chart( title='baz', margin=layout_pb2.MarginChartContent(series=[ layout_pb2.MarginChartContent.Series( value='loss/baz/scalar_summary', lower='loss/baz_lower/scalar_summary', upper='loss/baz_upper/scalar_summary'), ], )), ]), layout_pb2.Category( title='trig functions', chart=[ layout_pb2.Chart( title='wave trig functions', multiline=layout_pb2.MultilineChartContent(tag=[ r'trigFunctions/cosine', r'trigFunctions/sine' ], )), # The range of tangent is different. Give it its own chart. layout_pb2.Chart( title='tan', multiline=layout_pb2.MultilineChartContent( tag=[r'trigFunctions/tangent'], )), ], # This category we care less about. Make it initially closed. closed=True), ])) writer.add_summary(layout_summary) for i in xrange(42): summary = sess.run(merged_summary, feed_dict={step: i}) writer.add_summary(summary, global_step=i)
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 start_runs(logdir, steps, run_name, thresholds, mask_every_other_prediction=False): """Generate a PR curve with precision and recall evenly weighted. Arguments: logdir: The directory into which to store all the runs' data. steps: The number of steps to run for. run_name: The name of the run. thresholds: The number of thresholds to use for PR curves. mask_every_other_prediction: Whether to mask every other prediction by alternating weights between 0 and 1. """ tf.reset_default_graph() tf.set_random_seed(42) # Create a normal distribution layer used to generate true color labels. distribution = tf.distributions.Normal(loc=0., scale=142.) # Sample the distribution to generate colors. Lets generate different numbers # of each color. The first dimension is the count of examples. # The calls to sample() are given fixed random seed values that are "magic" # in that they correspond to the default seeds for those ops when the PR # curve test (which depends on this code) was written. We've pinned these # instead of continuing to use the defaults since the defaults are based on # node IDs from the sequence of nodes added to the graph, which can silently # change when this code or any TF op implementations it uses are modified. # TODO(nickfelt): redo the PR curve test to avoid reliance on random seeds. # Generate reds. number_of_reds = 100 true_reds = tf.clip_by_value( tf.concat([ 255 - tf.abs(distribution.sample([number_of_reds, 1], seed=11)), tf.abs(distribution.sample([number_of_reds, 2], seed=34)) ], axis=1), 0, 255) # Generate greens. number_of_greens = 200 true_greens = tf.clip_by_value( tf.concat([ tf.abs(distribution.sample([number_of_greens, 1], seed=61)), 255 - tf.abs(distribution.sample([number_of_greens, 1], seed=82)), tf.abs(distribution.sample([number_of_greens, 1], seed=105)) ], axis=1), 0, 255) # Generate blues. number_of_blues = 150 true_blues = tf.clip_by_value( tf.concat([ tf.abs(distribution.sample([number_of_blues, 2], seed=132)), 255 - tf.abs(distribution.sample([number_of_blues, 1], seed=153)) ], axis=1), 0, 255) # Assign each color a vector of 3 booleans based on its true label. labels = tf.concat([ tf.tile(tf.constant([[True, False, False]]), (number_of_reds, 1)), tf.tile(tf.constant([[False, True, False]]), (number_of_greens, 1)), tf.tile(tf.constant([[False, False, True]]), (number_of_blues, 1)), ], axis=0) # We introduce 3 normal distributions. They are used to predict whether a # color falls under a certain class (based on distances from corners of the # color triangle). The distributions vary per color. We have the distributions # narrow over time. initial_standard_deviations = [v + FLAGS.steps for v in (158, 200, 242)] iteration = tf.placeholder(tf.int32, shape=[]) red_predictor = tf.distributions.Normal( loc=0., scale=tf.cast(initial_standard_deviations[0] - iteration, dtype=tf.float32)) green_predictor = tf.distributions.Normal( loc=0., scale=tf.cast(initial_standard_deviations[1] - iteration, dtype=tf.float32)) blue_predictor = tf.distributions.Normal( loc=0., scale=tf.cast(initial_standard_deviations[2] - iteration, dtype=tf.float32)) # Make predictions (assign 3 probabilities to each color based on each color's # distance to each of the 3 corners). We seek double the area in the right # tail of the normal distribution. examples = tf.concat([true_reds, true_greens, true_blues], axis=0) probabilities_colors_are_red = (1 - red_predictor.cdf( tf.norm(examples - tf.constant([255., 0, 0]), axis=1))) * 2 probabilities_colors_are_green = (1 - green_predictor.cdf( tf.norm(examples - tf.constant([0, 255., 0]), axis=1))) * 2 probabilities_colors_are_blue = (1 - blue_predictor.cdf( tf.norm(examples - tf.constant([0, 0, 255.]), axis=1))) * 2 predictions = (probabilities_colors_are_red, probabilities_colors_are_green, probabilities_colors_are_blue) # This is the crucial piece. We write data required for generating PR curves. # We create 1 summary per class because we create 1 PR curve per class. for i, color in enumerate(('red', 'green', 'blue')): description = ( 'The probabilities used to create this PR curve are ' 'generated from a normal distribution. Its standard ' 'deviation is initially %0.0f and decreases over time.' % initial_standard_deviations[i]) weights = None if mask_every_other_prediction: # Assign a weight of 0 to every even-indexed prediction. Odd-indexed # predictions are assigned a default weight of 1. consecutive_indices = tf.reshape(tf.range(tf.size(predictions[i])), tf.shape(predictions[i])) weights = tf.cast(consecutive_indices % 2, dtype=tf.float32) summary.op(name=color, labels=labels[:, i], predictions=predictions[i], num_thresholds=thresholds, weights=weights, display_name='classifying %s' % color, description=description) merged_summary_op = tf.summary.merge_all() events_directory = os.path.join(logdir, run_name) sess = tf.Session() writer = tf.summary.FileWriter(events_directory, sess.graph) for step in xrange(steps): feed_dict = { iteration: step, } merged_summary = sess.run(merged_summary_op, feed_dict=feed_dict) writer.add_summary(merged_summary, step) writer.close()
def setUp(self): self.log_dir = tempfile.mkdtemp() # We use numpy.random to generate audio. We seed to avoid non-determinism # in this test. numpy.random.seed(42) # Create old-style audio summaries for run "foo". tf.reset_default_graph() sess = tf.Session() placeholder = tf.placeholder(tf.float32) tf.summary.audio(name="baz", tensor=placeholder, sample_rate=44100) merged_summary_op = tf.summary.merge_all() foo_directory = os.path.join(self.log_dir, "foo") writer = tf.summary.FileWriter(foo_directory) writer.add_graph(sess.graph) for step in xrange(2): # The floats (sample data) range from -1 to 1. writer.add_summary(sess.run( merged_summary_op, feed_dict={placeholder: numpy.random.rand(42, 22050) * 2 - 1}), global_step=step) writer.close() # Create new-style audio summaries for run "bar". tf.reset_default_graph() sess = tf.Session() audio_placeholder = tf.placeholder(tf.float32) labels_placeholder = tf.placeholder(tf.string) summary.op("quux", audio_placeholder, sample_rate=44100, labels=labels_placeholder, description="how do you pronounce that, anyway?") merged_summary_op = tf.summary.merge_all() bar_directory = os.path.join(self.log_dir, "bar") writer = tf.summary.FileWriter(bar_directory) writer.add_graph(sess.graph) for step in xrange(2): # The floats (sample data) range from -1 to 1. writer.add_summary(sess.run( merged_summary_op, feed_dict={ audio_placeholder: numpy.random.rand(42, 11025, 1) * 2 - 1, labels_placeholder: [ tf.compat.as_bytes('step **%s**, sample %s' % (step, sample)) for sample in xrange(42) ], }), global_step=step) writer.close() # Start a server with the plugin. multiplexer = event_multiplexer.EventMultiplexer({ "foo": foo_directory, "bar": bar_directory, }) context = base_plugin.TBContext(logdir=self.log_dir, multiplexer=multiplexer) self.plugin = audio_plugin.AudioPlugin(context) # Setting a reload interval of -1 disables reloading. We disable reloading # because we seek to block tests from running til after one reload finishes. # This setUp method thus manually reloads the multiplexer. TensorBoard would # otherwise reload in a non-blocking thread. wsgi_app = application.TensorBoardWSGIApp(self.log_dir, [self.plugin], multiplexer, reload_interval=-1, path_prefix='') self.server = werkzeug_test.Client(wsgi_app, wrappers.BaseResponse) multiplexer.Reload()
def test_when_shape_not_statically_known(self): placeholder = tf.placeholder(tf.float64, shape=None) reshaped = self.gaussian.reshape((25, -1)) self.compute_and_check_summary_pb(data=reshaped, data_tensor=placeholder, feed_dict={placeholder: reshaped})
def initialize_graph(self): self._image_placeholder = tf.placeholder(dtype=tf.uint8, name='image_to_encode') self._encode_op = tf.image.encode_png(self._image_placeholder)
def initialize_graph(self): self._input = tf.placeholder(tf.int32) self._squarer = tf.square(self._input)