Introduction

Updating a TensorFlow object detection model with new images usually means fine-tuning the model on an expanded dataset, not editing the exported model directly. The workflow is straightforward once you separate three concerns: preparing the new annotations, deciding whether the class list changed, and training from a checkpoint rather than from an already-exported inference artifact. If you skip that structure, it is easy to waste time retraining the wrong thing.

Decide What Kind of Update You Are Making

There are two common scenarios:

• you have more images for the same classes
• you are adding new object classes

If the classes are unchanged, the update is mostly about improving coverage and reducing false positives or false negatives. If new classes are added, you must also update the label mapping and the detection head configuration.

That distinction matters because it changes what can be reused from the previous training setup.

Do Not Retrain from the Exported Inference Model

A frequent mistake is trying to "update" an exported SavedModel or frozen inference graph as if it were the training checkpoint. For modern TensorFlow object detection workflows, you should fine-tune from a checkpoint and training configuration, then export again after training.

The reliable pattern is:

1. collect and annotate new images
2. merge or rebalance the dataset
3. convert the annotations into the format your training pipeline expects
4. fine-tune from a pretrained or previously trained checkpoint
5. export a fresh inference model

That keeps the model, labels, and preprocessing pipeline aligned.

Prepare the New Data Carefully

High-quality annotations matter more than simply adding many files. Before training, verify:

• class names are spelled consistently
• bounding boxes are in the expected coordinate format
• train and validation splits still make sense
• older data is not accidentally dropped

If you fine-tune only on the newest images, the model can overfit the new examples and forget earlier variation. In practice, it is usually better to train on a combined dataset containing both the previous images and the new ones.

With TensorFlow Model Garden, object detection tutorials commonly convert the dataset into TFRecord files. For COCO-style annotations, the conversion step can look like this:

1python -m official.vision.data.create_coco_tf_record \
2  --image_dir=./dataset/train \
3  --object_annotations_file=./dataset/train_annotations.json \
4  --output_file_prefix=./records/train \
5  --num_shards=1

Repeat the same process for validation data.

Fine-Tune from a Checkpoint

The current TensorFlow Model Garden object detection workflow is built around an experiment configuration and a checkpoint. A minimal example looks like this:

1from official.core import exp_factory
2
3exp_config = exp_factory.get_exp_config("retinanet_resnetfpn_coco")
4
5exp_config.task.model.num_classes = 4   # 3 classes + background
6exp_config.task.freeze_backbone = False
7exp_config.task.train_data.input_path = "./records/train-00000-of-00001.tfrecord"
8exp_config.task.validation_data.input_path = "./records/valid-00000-of-00001.tfrecord"
9exp_config.task.init_checkpoint = "/path/to/checkpoint"

If you are continuing from your own earlier training run, use that checkpoint. If you are starting from a general pretrained detector, use the model's pretrained checkpoint and fine-tune on your custom data.

The important part is that training continues from weights, not from an exported inference package.

Update the Label Space Only When Needed

If you are adding more examples of the same classes, do not change the class IDs or label mapping. Keep them stable so the model head stays compatible with the existing task.

If you are adding a new class, then you must:

• update the label map
• update num_classes
• ensure all annotations use the correct IDs
• fine-tune with a detector configuration that matches the expanded label space

A mismatch between labels and num_classes is one of the fastest ways to create confusing training failures.

Export and Re-Test the Updated Model

After training, export a new inference model and run it on representative images from both the old and new data. This is the step many people rush through, but it is the only way to catch regression.

At minimum, test:

• original examples the old model handled well
• new examples that motivated the retraining
• edge cases with cluttered backgrounds or small objects

That tells you whether the update improved the model or merely shifted its mistakes.

A Practical Strategy for Small Updates

If you only added a modest number of new images, you often do not need to redesign the entire pipeline. Start with the same architecture and training configuration, update the dataset, and fine-tune for a shorter run. This is cheaper and easier to compare against the previous model.

If the new images represent a major domain shift, such as different lighting, cameras, or object scales, expect to revisit augmentation, image size, and training duration as well.

Common Pitfalls

One common mistake is training only on the new images. That can hurt performance on older examples because the model stops seeing the full original distribution.

Another mistake is trying to continue training from an exported inference artifact instead of a checkpoint. In TensorFlow detection workflows, checkpoints are for training and exported models are for serving.

Developers also sometimes forget to update the label mapping when new classes are introduced, or they change the label IDs in a way that breaks compatibility with earlier data.

Finally, do not judge the update only by training loss. Always run inference on old and new validation images, because object detection regressions are easier to see visually than to infer from one scalar metric.

Summary

• Updating a TensorFlow object detector means fine-tuning on an expanded dataset, not editing the exported model directly.
• Keep old and new training images together unless you have a very specific reason not to.
• Use checkpoints for continued training and export a fresh model afterward.
• If the class set changes, update both the label map and num_classes.
• Validate the updated detector on both old and new examples so you catch regressions early.