Introduction

If you see multiple copies of a graph in TensorBoard while using a custom tf.Estimator, the problem is usually not TensorBoard itself. It is usually caused by writing the graph more than once, often through manual summary writers, reusing the same log directory for different modes, or creating separate train and eval runs that each export a graph.

Understand why duplicates happen with Estimator

tf.estimator.Estimator builds separate graphs for different modes such as TRAIN, EVAL, and PREDICT. On top of that, custom hooks or manual FileWriter calls can add the graph repeatedly.

Common duplicate sources are:

• calling writer.add_graph(...) in more than one place
• using the same events directory for both train and eval summaries
• rebuilding the graph and exporting it again in each session

For modern TensorFlow projects, Keras plus callbacks is usually the preferred stack. But if you are still maintaining an Estimator codebase, the fix is to decide exactly one place where the graph should be written.

The simplest fix: let training own the graph

If your training job already writes summaries, the cleanest approach is often:

• write the graph only for TRAIN
• do not manually write the graph in EVAL
• keep train and eval summaries in separate directories

Conceptually, that means your model_fn should avoid extra graph-writing logic unless it is strictly necessary.

For example, this is the pattern to avoid:

writer = tf.compat.v1.summary.FileWriter(model_dir)
writer.add_graph(tf.compat.v1.get_default_graph())

If that code appears in multiple sessions or hooks, you will get repeated graph exports.

If you must write it yourself, guard it explicitly

When you really need manual control, write the graph once through a hook that only runs for training:

1import tensorflow as tf
2
3
4class WriteGraphOnceHook(tf.estimator.SessionRunHook):
5    def __init__(self, logdir: str, enabled: bool):
6        self.logdir = logdir
7        self.enabled = enabled
8
9    def begin(self):
10        if not self.enabled:
11            return
12        writer = tf.compat.v1.summary.FileWriterCache.get(self.logdir)
13        writer.add_graph(tf.compat.v1.get_default_graph())
14        writer.flush()

Then attach it only in TRAIN mode:

1def model_fn(features, labels, mode, params):
2    predictions = tf.keras.layers.Dense(1)(features["x"])
3    loss = tf.reduce_mean(tf.square(predictions - labels))
4
5    if mode == tf.estimator.ModeKeys.TRAIN:
6        optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=0.001)
7        train_op = optimizer.minimize(
8            loss,
9            global_step=tf.compat.v1.train.get_or_create_global_step()
10        )
11        hooks = [WriteGraphOnceHook(params["model_dir"], enabled=True)]
12        return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op, training_hooks=hooks)
13
14    if mode == tf.estimator.ModeKeys.EVAL:
15        return tf.estimator.EstimatorSpec(mode, loss=loss)
16
17    return tf.estimator.EstimatorSpec(mode, predictions={"y": predictions})

The important part is not the hook itself. The important part is that the graph export path is centralized and restricted to one mode.

Keep train and eval logs separate

Even without manual graph writing, mixing all summaries into one directory can make debugging harder. A clearer setup is:

1config = tf.estimator.RunConfig(save_summary_steps=100)
2estimator = tf.estimator.Estimator(
3    model_fn=model_fn,
4    model_dir="runs/experiment-1",
5    config=config,
6    params={"model_dir": "runs/experiment-1"},
7)

Then let Estimator place evaluation outputs in its own subdirectory during train_and_evaluate. That keeps the training event stream cleaner and reduces confusion about which graph belongs to which execution mode.

If you are launching TensorBoard against the entire experiment directory, remember that multiple runs can still appear in the UI. That does not necessarily mean the same graph was written into one single event stream.

Avoid writing graphs inside every step or summary callback

Another common mistake is treating graph export like a scalar summary and writing it repeatedly. The graph definition is structural metadata, not a per-step metric.

Write scalar summaries often if needed. Write the graph once.

If a custom callback or hook is running every step, it should not call add_graph(...). That guarantees duplication and grows event files unnecessarily.

Common Pitfalls

The biggest mistake is manually calling add_graph(...) while also relying on Estimator or another hook to manage summary writing.

Another common issue is assuming every graph shown in TensorBoard is a duplicate bug. Sometimes you are looking at separate train and eval runs, which is expected.

People also reuse the same log directory for unrelated experiments. That makes TensorBoard look noisy even when each individual run is correct.

Finally, keep in mind that tf.Estimator is a legacy API. If you are building something new, Keras with TensorBoard callbacks is usually easier to control.

Summary

• Duplicate graphs usually come from multiple graph exports, not from TensorBoard itself.
• With Estimator, write the graph in one place, ideally only for TRAIN.
• Avoid manual add_graph(...) calls unless you really need them.
• Keep train and eval event directories separate so runs stay understandable.
• For new projects, prefer Keras and TensorBoard callbacks over fresh Estimator-based code.