TensorFlow Serving setup - Model Metrics & Evaluation

Metrics & Evaluation - TensorFlow Serving setup

Which metric matters for TensorFlow Serving setup and WHY

When setting up TensorFlow Serving, the key metrics to watch are latency and throughput. Latency tells us how fast the model responds to a request, which is important for user experience. Throughput shows how many requests the server can handle per second, which matters for scaling. Accuracy and loss are important but are usually checked before deployment. Here, we focus on serving performance to ensure the model predictions come quickly and reliably.

Confusion matrix or equivalent visualization

TensorFlow Serving itself does not produce a confusion matrix, but the model it serves does. For example, if the model is a classifier, you can collect predictions and true labels from the served model to build a confusion matrix like this:

      | Predicted Positive | Predicted Negative |
      |--------------------|--------------------|
      | True Positive (TP)  | False Negative (FN) |
      | False Positive (FP) | True Negative (TN)  |
    

This matrix helps calculate precision, recall, and other metrics to evaluate model quality after serving.

Precision vs Recall tradeoff with concrete examples

While TensorFlow Serving focuses on delivering predictions fast, the model's precision and recall affect how useful those predictions are. For example:

• Spam filter: High precision means fewer good emails marked as spam, so users don't miss important messages.
• Medical diagnosis: High recall means catching most disease cases, even if some false alarms happen.

TensorFlow Serving must handle these predictions efficiently, but the model's precision and recall guide how the predictions are interpreted.

What "good" vs "bad" metric values look like for TensorFlow Serving setup

Good setup:

• Low latency (e.g., under 100 ms per request)
• High throughput (e.g., hundreds or thousands of requests per second)
• Stable uptime and no errors

Bad setup:

• High latency causing slow responses
• Low throughput leading to request backlogs
• Frequent crashes or errors

These performance metrics ensure the model predictions are delivered quickly and reliably to users.

Metrics pitfalls in TensorFlow Serving setup

• Ignoring latency spikes: Average latency may look good, but occasional spikes hurt user experience.
• Not monitoring throughput under load: Setup may work fine with few requests but fail under heavy traffic.
• Confusing model accuracy with serving performance: A highly accurate model is useless if serving is too slow or unreliable.
• Data leakage: If test data leaks into training, accuracy looks better but real-world performance suffers.
• Overfitting: Model performs well on training but poorly on new data, which serving metrics won't catch directly.

Self-check: Your model has 98% accuracy but 12% recall on fraud. Is it good?

No, this is not good for fraud detection. Even though accuracy is high, recall is very low, meaning the model misses most fraud cases. In fraud detection, missing fraud (low recall) is worse than false alarms. So, despite high accuracy, the model is not reliable for production fraud detection.

Key Result

For TensorFlow Serving, low latency and high throughput are key to delivering fast, reliable model predictions.

Practice

1. What is the main purpose of TensorFlow Serving in a machine learning workflow?

easy

A. To visualize training data and model metrics

B. To train new machine learning models from scratch

C. To preprocess data before training

D. To deploy trained models for real-time predictions

Solution

1. Step 1: Understand TensorFlow Serving's role

   TensorFlow Serving is designed to make trained models available for real-time use without retraining.

2. Step 2: Differentiate from other tasks

   Training, visualization, and preprocessing are separate steps not handled by TensorFlow Serving.

3. Final Answer:

   To deploy trained models for real-time predictions -> Option D

4. Quick Check:

   Serving = deploy models [OK]

Hint: Serving means making models ready for prediction [OK]

Common Mistakes:

• Confusing serving with training
• Thinking it handles data preprocessing
• Assuming it visualizes metrics

2. Which command correctly starts TensorFlow Serving to serve a model saved in the directory /models/my_model/1/ with model name my_model?

easy

A. tensorflow_model_server --model_name my_model --model_base_path /models/my_model/1/

B. tensorflow_model_server --model_name=my_model --model_path=/models/my_model/1/

C. tensorflow_model_server --model_name=my_model --model_base_path=/models/my_model/1/

D. tensorflow_serve --model_name=my_model --model_base_path=/models/my_model/1/

Solution

1. Step 1: Identify correct flags for TensorFlow Serving

   The correct flags are --model_name and --model_base_path with equal signs.

2. Step 2: Check command correctness

   tensorflow_model_server --model_name=my_model --model_base_path=/models/my_model/1/ uses correct command and flags with equal signs; others have syntax errors or wrong command name.

3. Final Answer:

   tensorflow_model_server --model_name=my_model --model_base_path=/models/my_model/1/ -> Option C

4. Quick Check:

   Correct flags and command = tensorflow_model_server --model_name=my_model --model_base_path=/models/my_model/1/ [OK]

Hint: Use equal signs with flags and correct command name [OK]

Common Mistakes:

• Using spaces instead of equal signs in flags
• Wrong command name like tensorflow_serve
• Using incorrect flag names like --model_path

3. Given the following Python code snippet to send data to a TensorFlow Serving REST API, what will be the printed output if the server returns a prediction of 0.85?

import requests
import json

url = 'http://localhost:8501/v1/models/my_model:predict'
data = {"instances": [[1.0, 2.0, 3.0]]}
response = requests.post(url, json=data)
prediction = response.json()['predictions'][0]
print(prediction)

medium

A. 0.85

B. [0.85]

C. {'predictions': [0.85]}

D. Error: KeyError

Solution

1. Step 1: Understand the response JSON structure

   The server returns a JSON with key 'predictions' holding a list of prediction values, e.g., {'predictions': [0.85]}.

2. Step 2: Extract the first prediction value

   Accessing response.json()['predictions'][0] extracts the float 0.85.

3. Final Answer:

   0.85 -> Option A

4. Quick Check:

   Extract first prediction value = 0.85 [OK]

Hint: Access ['predictions'][0] to get single prediction value [OK]

Common Mistakes:

• Printing the whole JSON instead of the value
• Forgetting to index the first prediction
• Assuming prediction is a list, not a float

4. You tried to start TensorFlow Serving with the command tensorflow_model_server --model_name=my_model --model_base_path=/models/my_model/1/ but got an error saying the model path does not exist. What is the most likely cause?

medium

A. The command should use --model_path instead of --model_base_path

B. The model directory path is incorrect or missing the version subfolder

C. TensorFlow Serving requires the model to be in a .pb file, not a folder

D. The model name must be the full path, not just a name

Solution

1. Step 1: Check model directory structure requirements

   TensorFlow Serving expects model_base_path to point to a directory containing version subfolders like '1', '2', etc.

2. Step 2: Identify common path mistakes

   If the path misses the version folder or is incorrect, the server cannot find the model and throws an error.

3. Final Answer:

   The model directory path is incorrect or missing the version subfolder -> Option B

4. Quick Check:

   Model path must include version folder [OK]

Hint: Model path must include version folder like /1/ [OK]

Common Mistakes:

• Using --model_path instead of --model_base_path
• Pointing to a file instead of a directory
• Confusing model name with path

5. You want to update your TensorFlow model served by TensorFlow Serving without downtime. Which approach allows you to serve the new model version while keeping the old version available for requests?

hard

A. Add the new model version in a new subfolder and update the model config file

B. Stop TensorFlow Serving, replace the old model folder, then restart the server

C. Serve the new model on a different port and manually switch clients

D. Retrain the model inside TensorFlow Serving using the new data

Solution

1. Step 1: Understand TensorFlow Serving versioning

   TensorFlow Serving supports multiple model versions by placing each version in its own numbered subfolder.

2. Step 2: Use model config file to add new version

   Adding the new version folder and updating the config allows serving both versions simultaneously without downtime.

3. Final Answer:

   Add the new model version in a new subfolder and update the model config file -> Option A

4. Quick Check:

   Versioned folders + config update = zero downtime [OK]

Hint: Use versioned folders and config to update without downtime [OK]

Common Mistakes:

• Replacing model folder while server runs
• Restarting server causes downtime
• Trying to retrain model inside serving