Introduction

If you are using the old TensorFlow InceptionV3 retraining example, the first thing to clarify is what “multiple classifications” means. For most people it means multi-class classification, where each image belongs to one class out of many. In that case, the script usually needs little or no structural editing because it already builds an output layer sized to the number of label folders it finds.

Multi-Class Retraining With the Original Script

The classic retrain.py or similarly named example works by scanning a directory tree and treating each subdirectory as one label. If your dataset has cats, dogs, and birds, you do not hardcode three outputs by hand. You place images into three folders and the script creates the final classifier layer with three logits.

A typical dataset layout looks like this:

1images/
2  cats/
3    cat-01.jpg
4    cat-02.jpg
5  dogs/
6    dog-01.jpg
7  birds/
8    bird-01.jpg

Then you run the retraining command against that root directory:

1python retrain.py \
2  --image_dir ./images \
3  --architecture inception_v3 \
4  --how_many_training_steps 2000 \
5  --output_graph ./output_graph.pb \
6  --output_labels ./output_labels.txt

The important detail is that the script infers the class count from the folders under --image_dir. If you add a fourth folder named horses, the model output layer becomes four-way automatically. For the common one-image-one-label case, that is the only change you need.

Under the hood, the script usually does three things:

1. It loads the pre-trained InceptionV3 graph.
2. It caches bottleneck features for each training image.
3. It trains a new final layer whose width matches the number of labels.

That means you should focus more on dataset organization than on editing the TensorFlow graph manually.

When You Actually Need Code Changes

You do need code changes if one image can belong to several labels at once. That is a multi-label problem, not a multi-class one. A photo might be both outdoor and sunset, for example. The old retraining example is generally built for a single target label per image and ends with a softmax style classifier.

For multi-label training, you need three conceptual changes:

1. Encode labels as multi-hot vectors instead of one label index.
2. Use a sigmoid output per label instead of softmax.
3. Train with binary cross-entropy instead of categorical cross-entropy.

In modern TensorFlow, it is often simpler to move to Keras rather than heavily patch the old example script. A small example looks like this:

1import tensorflow as tf
2
3num_labels = 5
4
5base_model = tf.keras.applications.InceptionV3(
6    include_top=False,
7    weights="imagenet",
8    input_shape=(299, 299, 3),
9    pooling="avg",
10)
11base_model.trainable = False
12
13inputs = tf.keras.Input(shape=(299, 299, 3))
14x = tf.keras.applications.inception_v3.preprocess_input(inputs)
15x = base_model(x, training=False)
16outputs = tf.keras.layers.Dense(num_labels, activation="sigmoid")(x)
17
18model = tf.keras.Model(inputs, outputs)
19model.compile(
20    optimizer="adam",
21    loss="binary_crossentropy",
22    metrics=["binary_accuracy"],
23)

With that model, a target such as [1, 0, 1, 0, 0] means the image belongs to labels one and three at the same time. That cannot be represented correctly by the original one-label retraining flow.

What to Edit in an Older TensorFlow Script

If you must keep the older script, inspect the parts that define the final layer and loss. In many versions, you will find a placeholder or tensor for the ground-truth labels, then a fully connected layer on top of the bottleneck tensor, and finally a cross-entropy calculation.

For a true multi-label setup, the edits usually include:

• changing the label placeholder shape from one class index to a full label vector
• replacing the softmax loss path with sigmoid cross-entropy
• updating evaluation logic so predictions can return several labels above a threshold

The prediction stage changes as well. In a softmax model, you often take the single highest score. In a sigmoid model, you pick every label whose probability is above a threshold such as 0.5:

1import numpy as np
2
3scores = np.array([0.91, 0.12, 0.74, 0.08, 0.53])
4labels = ["cat", "dog", "outdoor", "indoor", "sunset"]
5
6predicted = [name for name, score in zip(labels, scores) if score >= 0.5]
7print(predicted)

Common Pitfalls

The most common mistake is confusing multi-class with multi-label. If each image has exactly one class, the old retraining example already supports more than two classes through the folder layout alone.

Another common issue is inconsistent directory naming. The script treats folder names as labels, so Dog and dog may become separate classes depending on your workflow and operating system conventions.

Class imbalance also hurts transfer learning. If one folder has thousands of images and another has a few dozen, the final layer may look accurate overall while performing badly on the small classes. Balance the dataset or use class weighting.

Finally, many online answers refer to TensorFlow 1.x example scripts that are now dated. If you are starting new work, prefer a Keras-based pipeline because it is easier to inspect, easier to debug, and much easier to adapt when the target problem changes.

Summary

• For ordinary multi-class retraining, you usually do not edit retraining-example.py much at all.
• The number of output classes is normally inferred from the label subdirectories in your image folder.
• Real code changes are needed when one image can have several labels at once.
• Multi-label training requires sigmoid outputs, multi-hot targets, and binary cross-entropy.
• For new projects, a small Keras model on top of InceptionV3 is usually cleaner than patching the old example script.