Loading and inference in TensorFlow - Deep Dive

Overview - Loading and inference

What is it?

Loading and inference means taking a saved machine learning model and using it to make predictions on new data. Loading is about opening the model file and preparing it to work again. Inference is the process where the model looks at new input and gives an output, like guessing a label or number. This lets us use trained models without retraining them every time.

Why it matters

Without loading and inference, every time we want to use a model, we would have to train it from scratch, which takes a lot of time and computing power. Loading and inference let us reuse models easily and quickly, making AI practical for real-world tasks like recognizing images, translating languages, or recommending products. It turns training into useful predictions.

Where it fits

Before learning loading and inference, you should understand how to build and train models in TensorFlow. After this, you can learn about optimizing inference speed, deploying models to devices or servers, and handling model versioning in production.

Mental Model

Core Idea

Loading and inference is like opening a saved recipe book (loading) and following a recipe to cook a meal (inference) without rewriting the recipe.

Think of it like...

Imagine you wrote down your favorite cake recipe and saved it in a cookbook. Loading is like opening that cookbook to the right page. Inference is like using the recipe to bake a cake whenever you want, without having to invent the recipe again.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Saved Model   │──────▶│ Load Model    │──────▶│ Inference     │
│ (File on disk)│       │ (Prepare for  │       │ (Make         │
│               │       │  use)         │       │  predictions) │
└───────────────┘       └───────────────┘       └───────────────┘

Build-Up - 7 Steps

1

Foundation

What is a Saved Model in TensorFlow

Concept: Introduce the idea of saving a trained model to disk in TensorFlow format.

After training a model, TensorFlow lets you save it as a SavedModel format. This includes the model's architecture, weights, and metadata. You save it using model.save('path'). This file can be loaded later to use the model without retraining.

Result

You get a folder with files that store your model's structure and learned parameters.

Understanding that a model is more than just code—it includes learned data—helps you see why saving and loading is essential for reuse.

2

Foundation

Basic Model Loading with tf.keras.models.load_model

Concept: Learn how to load a saved model back into memory using TensorFlow's API.

Use tf.keras.models.load_model('path') to load your saved model. This restores the model exactly as it was, ready to make predictions. You can then call model.predict(new_data) to get outputs.

Result

The model is ready in memory and can process new inputs immediately.

Knowing the exact function to load models is the first step to using trained models in practice.

3

Intermediate

Running Inference on New Data

🤔Before reading on: Do you think inference requires retraining the model or just feeding new data? Commit to your answer.

Concept: Understand that inference means using the model to predict outputs from new inputs without changing the model.

Once loaded, you pass new input data to model.predict(). The model processes this data through its layers and returns predictions. This step does not change the model's weights or structure.

Result

You get predictions like class labels, probabilities, or numbers for your new inputs.

Recognizing inference as a read-only use of the model prevents confusion about when training happens.

4

Intermediate

Handling Input Shapes and Preprocessing

🤔Before reading on: Should input data during inference be exactly like training data? Yes or no? Commit to your answer.

Concept: Learn that input data must match the shape and format the model expects, often requiring preprocessing.

Models expect inputs in a specific shape and scale. For example, images might need resizing and normalization. If inputs don't match, inference will fail or give wrong results. Preprocessing steps used during training must be repeated before inference.

Result

Correctly formatted inputs lead to valid and accurate predictions.

Understanding input consistency is key to reliable inference and avoiding silent errors.

5

Intermediate

Using TensorFlow SavedModel for Serving

Concept: Explore the SavedModel format as a standard for TensorFlow serving and deployment.

SavedModel is a universal format that includes the computation graph and weights. It supports TensorFlow Serving and other deployment tools. You can load it with tf.saved_model.load() for lower-level control or use it in production servers.

Result

Models saved in this format can be deployed and served efficiently in various environments.

Knowing the SavedModel format's role bridges training and production deployment.

6

Advanced

Optimizing Inference with TensorFlow Functions

🤔Before reading on: Do you think inference speed can be improved by converting models to TensorFlow functions? Yes or no? Commit to your answer.

Concept: Learn how wrapping model calls in tf.function can speed up inference by compiling the computation graph.

TensorFlow's tf.function decorator compiles Python code into a fast graph. Wrapping inference code with tf.function reduces overhead and speeds up predictions, especially in repeated calls or batch processing.

Result

Inference runs faster and uses resources more efficiently.

Understanding how graph compilation improves speed helps in building responsive AI applications.

7

Expert

Surprising Effects of Model Loading on Device Placement

🤔Before reading on: When loading a model, do you think TensorFlow always places it on the CPU by default? Commit to yes or no.

Concept: Discover how TensorFlow decides where to place model operations (CPU/GPU) when loading and how this affects inference performance.

When you load a model, TensorFlow may place it on CPU or GPU depending on availability and configuration. Sometimes models load on CPU by default, causing slower inference if GPU is available but unused. Explicit device placement or environment setup is needed to ensure optimal performance.

Result

Inference speed can vary greatly depending on device placement after loading.

Knowing device placement behavior prevents unexpected slowdowns and helps optimize inference in production.

Under the Hood

When you save a TensorFlow model, it stores the model's architecture as a computation graph and the learned weights as binary data. Loading reconstructs this graph and restores weights in memory. During inference, input data flows through this graph, activating nodes (layers) that perform calculations to produce outputs. TensorFlow manages device placement and memory allocation dynamically during this process.

Why designed this way?

TensorFlow uses the SavedModel format to separate model definition from code, enabling language-agnostic deployment and efficient serving. This design supports portability, versioning, and optimization. Alternatives like saving only weights or code were less flexible and harder to deploy at scale.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ SavedModel    │──────▶│ Load Graph    │──────▶│ Restore Weights│
│ Filesystem    │       │ into Memory   │       │ into Graph     │
└───────────────┘       └───────────────┘       └───────────────┘
                                   │
                                   ▼
                          ┌─────────────────┐
                          │ Inference Input  │
                          └─────────────────┘
                                   │
                                   ▼
                          ┌─────────────────┐
                          │ Computation Graph│
                          │ (Layers & Ops)   │
                          └─────────────────┘
                                   │
                                   ▼
                          ┌─────────────────┐
                          │ Prediction Output│
                          └─────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does loading a model automatically mean it will run on GPU? Commit to yes or no.

Common Belief: Loading a model automatically uses the GPU if available.

Reality: TensorFlow may load the model on CPU by default unless explicitly configured to use GPU.

Why it matters: Assuming GPU use can lead to slow inference and wasted resources if the model runs on CPU unexpectedly.

Quick: Is inference the same as training? Commit to yes or no.

Common Belief: Inference involves training the model again on new data.

Reality: Inference only uses the trained model to make predictions without changing weights.

Why it matters: Confusing inference with training wastes time and resources and can cause errors.

Quick: Can you feed any shape of input data to a loaded model? Commit to yes or no.

Common Belief: You can input any shape or format of data during inference.

Reality: Input data must match the shape and preprocessing used during training exactly.

Why it matters: Mismatched inputs cause errors or wrong predictions, leading to unreliable results.

Quick: Does saving a model only save its weights? Commit to yes or no.

Common Belief: Saving a model only stores the weights; architecture must be recreated manually.

Reality: SavedModel format stores both architecture and weights together for easy loading.

Why it matters: Misunderstanding this leads to complicated and error-prone model restoration.

Expert Zone

1

Loading a model can trigger lazy loading of weights, meaning weights are only loaded into memory when first used, saving startup time.

2

TensorFlow's SavedModel supports multiple signatures (different input-output formats) allowing one model to serve various tasks without reloading.

3

Inference performance depends heavily on batch size; small batches may underutilize hardware, while large batches improve throughput but increase latency.

When NOT to use

Loading and inference with TensorFlow SavedModel is not ideal for extremely low-latency or resource-constrained environments like microcontrollers. In such cases, specialized lightweight runtimes like TensorFlow Lite or ONNX Runtime are better suited.

Production Patterns

In production, models are often loaded once at server startup and kept in memory for repeated inference calls. Model versioning and A/B testing are used to switch between models without downtime. Batch inference pipelines process large datasets offline using loaded models.

Connections

Serialization in Software Engineering

Loading a model is a form of deserialization, restoring an object from saved data.

Understanding serialization helps grasp how models are saved and restored as structured data, enabling reuse across sessions.

Cache Systems in Computer Science

Inference uses loaded models like a cache uses stored data to speed up repeated access.

Knowing caching principles clarifies why keeping models loaded in memory improves prediction speed.

Recipe Books in Cooking

Loading and inference parallels opening a recipe book and following a recipe to cook without inventing it again.

This connection highlights the value of reusing knowledge (models) efficiently without repeating costly creation (training).

Common Pitfalls

#1 Trying to predict with a model before loading it.

Wrong approach:

model = None
predictions = model.predict(new_data)

Correct approach:

model = tf.keras.models.load_model('path')
predictions = model.predict(new_data)

Root cause:

Not understanding that the model must be loaded into memory before use.

#2 Feeding raw input data without preprocessing during inference.

Wrong approach:

predictions = model.predict(raw_images)

Correct approach:

processed_images = preprocess(raw_images)
predictions = model.predict(processed_images)

Root cause:

Ignoring that input data must match the format used during training.

#3 Assuming inference runs on GPU without setting device or environment properly.

Wrong approach:

model = tf.keras.models.load_model('path')
predictions = model.predict(data) # runs on CPU unexpectedly

Correct approach:

with tf.device('/GPU:0'):
model = tf.keras.models.load_model('path')
predictions = model.predict(data)

Root cause:

Not configuring TensorFlow device placement explicitly.

Key Takeaways

Loading a model means restoring its saved architecture and weights so it can be used again without retraining.

Inference is using the loaded model to make predictions on new data without changing the model itself.

Input data during inference must be preprocessed and shaped exactly as during training to get correct results.

TensorFlow's SavedModel format supports easy deployment and serving of models across different environments.

Device placement and optimization techniques like tf.function can greatly affect inference speed and efficiency.

Practice

1. What is the main purpose of tf.keras.models.load_model() in TensorFlow?

easy

A. To visualize the model architecture

B. To load a previously saved model for inference or further training

C. To compile a model with loss and optimizer

D. To create a new model architecture from scratch

Solution

1. Step 1: Understand the function purpose

   tf.keras.models.load_model() is used to load a model that was saved earlier, including its architecture, weights, and optimizer state.

2. Step 2: Differentiate from other functions

   Creating a new model or compiling it are separate steps. Loading is specifically for retrieving a saved model.

3. Final Answer:

   To load a previously saved model for inference or further training -> Option B

4. Quick Check:

   Load saved model = load_model() [OK]

Hint: Load saved models with load_model() function [OK]

Common Mistakes:

• Confusing load_model() with model creation
• Thinking load_model() compiles the model
• Assuming load_model() only loads weights

2. Which of the following is the correct way to get predictions from a loaded TensorFlow model named model on input data new_data?

easy

A. predictions = model.predict(new_data)

B. predictions = model.fit(new_data)

C. predictions = model.evaluate(new_data)

D. predictions = model.compile(new_data)

Solution

1. Step 1: Identify the correct method for inference

   To get predictions from a model, the method predict() is used.

2. Step 2: Understand other methods

   fit() trains the model, evaluate() tests performance, and compile() sets up the model.

3. Final Answer:

   predictions = model.predict(new_data) -> Option A

4. Quick Check:

   Predict new data = model.predict() [OK]

Hint: Use model.predict() to get predictions [OK]

Common Mistakes:

• Using fit() instead of predict() for inference
• Calling evaluate() expecting predictions
• Trying to compile() during prediction

3. Given the following code, what will be the shape of predictions?

import tensorflow as tf
import numpy as np
model = tf.keras.Sequential([
  tf.keras.layers.Dense(3, input_shape=(4,))
])
model.compile(optimizer='adam', loss='mse')
input_data = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
predictions = model.predict(input_data)

medium

A. (3, 4)

B. (4, 3)

C. (2, 3)

D. (2, 4)

Solution

1. Step 1: Analyze input shape and batch size

   The input data has shape (2, 4) meaning 2 samples, each with 4 features.

2. Step 2: Determine output shape from model layer

   The Dense layer outputs 3 units per sample, so output shape is (2, 3).

3. Final Answer:

   (2, 3) -> Option C

4. Quick Check:

   Input batch 2, output units 3 = (2, 3) [OK]

Hint: Output shape = (batch_size, units in last layer) [OK]

Common Mistakes:

• Confusing input shape with output shape
• Mixing batch size and feature dimensions
• Assuming output shape matches input shape

4. You loaded a model with model = tf.keras.models.load_model('my_model') but get this error when calling model.predict(new_data): ValueError: Error when checking input: expected dense_input to have shape (4,) but got array with shape (3,). What is the likely cause?

medium

A. The input data shape does not match the model's expected input shape

B. The model was not compiled before prediction

C. The model file is corrupted

D. The predict() method was called without training the model

Solution

1. Step 1: Understand the error message

   The error says the model expects input shape (4,), but received (3,), meaning input data shape is wrong.

2. Step 2: Rule out other causes

   Model compilation is not required for prediction, corrupted files cause different errors, and training is not needed for predict().

3. Final Answer:

   The input data shape does not match the model's expected input shape -> Option A

4. Quick Check:

   Input shape mismatch = ValueError [OK]

Hint: Match input data shape to model input shape exactly [OK]

Common Mistakes:

• Ignoring input shape mismatch
• Thinking model must be compiled before predict
• Assuming predict requires training first

5. You have a saved TensorFlow model that expects input shape (None, 5). You want to predict on a single sample with 5 features stored in a list sample = [1, 2, 3, 4, 5]. Which code snippet correctly prepares the input and gets the prediction?

hard

A. input_data = np.array(sample)
prediction = model.predict(input_data)

B. input_data = np.array(sample).reshape(1, 1, 5)
prediction = model.predict(input_data)

C. input_data = np.array(sample).reshape(5, 1)
prediction = model.predict(input_data)

D. import numpy as np
input_data = np.array([sample])
prediction = model.predict(input_data)

Solution

1. Step 1: Understand model input shape

   The model expects input shape (None, 5), where None is batch size, so input must be 2D with shape (batch_size, 5).

2. Step 2: Prepare input data correctly

   Wrapping the sample list in another list creates shape (1, 5), which matches expected input.

3. Step 3: Check other options

   input_data = np.array(sample) prediction = model.predict(input_data) gives shape (5,), not 2D; input_data = np.array(sample).reshape(5, 1) prediction = model.predict(input_data) reshapes to (5,1) which is wrong; input_data = np.array(sample).reshape(1, 1, 5) prediction = model.predict(input_data) reshapes to (1,1,5) which is 3D and incorrect.

4. Final Answer:

   import numpy as np input_data = np.array([sample]) prediction = model.predict(input_data) -> Option D

5. Quick Check:

   Input shape (1,5) matches model input [OK]

Hint: Wrap single sample in list to add batch dimension [OK]

Common Mistakes:

• Passing 1D array instead of 2D batch input
• Incorrect reshaping causing wrong input dimensions
• Adding extra unnecessary dimensions