Introduction

Adding your own classes to a pre-trained Inception model is really a transfer-learning problem, not a matter of appending one extra label to the existing softmax and hoping the model understands it. If you want custom classes while still keeping the original ImageNet predictions, the clean solution is usually to reuse the Inception feature extractor and attach a separate custom classification head.

What the Pre-trained Inception Model Actually Gives You

A pre-trained Inception network has learned rich visual features from ImageNet. Those features are useful beyond the original thousand classes, which is why transfer learning works so well.

What the original top layer does not give you is a true semantic hierarchy you can extend cleanly. The ImageNet output is a flat probability distribution over the model's trained classes. If your application needs:

• original ImageNet predictions
• new custom classes
• some higher-level grouping of results

then it is usually better to separate those concerns instead of trying to force one old classifier head to do everything.

Reusing the Inception Base for New Classes

In TensorFlow Keras, the standard pattern is to load the pre-trained base without the old classifier, then add your own head.

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

This gives you a new classifier for your own three classes while keeping the pre-trained convolutional features.

Keeping the Original ImageNet Predictions Too

If you also want the original ImageNet output, treat it as a separate branch or separate model. One practical approach is to keep an off-the-shelf Inception model with include_top=True for ImageNet predictions and a second transfer-learning model for your custom classes.

Conceptually, the workflow is:

• use one model for the original ImageNet label distribution
• use a second head, or a second model, for your project-specific classes
• map those outputs into your own application hierarchy if needed

That is much easier to reason about than trying to add one new class into the old thousand-way classifier without retraining the original label space thoroughly.

Fine-Tuning After the New Head Learns

A common training sequence is:

1. freeze the pre-trained Inception base
2. train the new classification head
3. unfreeze some of the upper convolutional layers
4. continue training with a smaller learning rate

1base_model.trainable = True
2
3for layer in base_model.layers[:-50]:
4    layer.trainable = False
5
6model.compile(
7    optimizer=tf.keras.optimizers.Adam(1e-5),
8    loss="sparse_categorical_crossentropy",
9    metrics=["accuracy"],
10)

This gives the new head a chance to stabilize before you start adjusting the shared visual features.

Building a Hierarchy Outside the Softmax

If by "full image hierarchy" you mean broader categories such as animal, vehicle, and furniture, that hierarchy usually belongs in your application logic or label taxonomy, not inside the original flat softmax layer itself.

For example, you can map predicted labels into parent categories after inference:

1hierarchy = {
2    "tabby": "animal",
3    "golden_retriever": "animal",
4    "sports_car": "vehicle",
5}

That is a cleaner representation of hierarchy than trying to reinterpret the dense output layer as a tree.

Common Pitfalls

The biggest pitfall is thinking you can append a single class to the old Inception classifier and keep the original behavior without retraining the output layer carefully. The classifier weights were learned for a fixed label space, so changing that space changes the task.

Another mistake is forgetting the required image size and preprocessing for Inception. Feeding the wrong input shape or skipping preprocess_input often hurts performance more than the transfer-learning code itself.

Developers also blur together "ImageNet classes" and "hierarchical categories." The original model predicts flat classes. If you need a hierarchy, define one separately and map predictions into it.

Summary

• Reuse the pre-trained Inception base as a feature extractor and add a new classifier head for your custom classes.
• Do not treat the original ImageNet softmax as something you can casually extend by one class.
• Keep original ImageNet predictions and custom predictions as separate outputs if you need both.
• Fine-tune only after the new head has learned the task reasonably well.
• Build semantic hierarchies in your label mapping layer rather than forcing them into the old classifier head.