Model serving for NLP - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary purpose of model serving in NLP?

Model serving is a key step after training an NLP model. What is its main goal?

A To visualize the training loss and accuracy curves

B To clean and preprocess the input text before training

C To deploy the trained model so it can make predictions on new text data in real time or batch

D To train the model on a larger dataset for better accuracy

💡 Hint

Think about what happens after a model is ready and you want to use it.

Model serving means making the trained NLP model available to accept new text inputs and return predictions, often in real time.

❓ Predict Output

intermediate

What output does this Flask model serving code produce?

Given this simple Flask app serving an NLP sentiment model, what is the JSON response when sending POST with text 'I love this!'?

NLP

from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    data = request.json
    text = data.get('text', '')
    # Dummy sentiment prediction
    sentiment = 'positive' if 'love' in text else 'negative'
    return jsonify({'sentiment': sentiment})

# Assume app.run() is called elsewhere

A {"error": "No text provided"}

B {"sentiment": "negative"}

C 500 Internal Server Error

D {"sentiment": "positive"}

💡 Hint

Check if the word 'love' is in the input text.

The code returns 'positive' sentiment if the word 'love' is found in the input text, otherwise 'negative'.

❓ Hyperparameter

advanced

Which batch size is best for serving an NLP model with low latency?

You want to serve an NLP model that responds quickly to single user requests. Which batch size should you choose?

A Batch size of 1 to minimize waiting time per request

B Batch size of 64 to maximize GPU throughput

C Batch size of 128 to reduce memory usage

D Batch size of 256 to increase model accuracy

💡 Hint

Think about how batch size affects response time for individual requests.

For low latency serving, batch size 1 is best because it processes each request immediately without waiting to fill a batch.

❓ Metrics

advanced

Which metric best measures NLP model serving quality in production?

To monitor an NLP model serving system, which metric directly reflects user experience quality?

A Loss value during training

B Average response latency (time to get prediction)

C Number of model parameters

D Training accuracy on the original dataset

💡 Hint

Think about what users notice when using a model service.

Users care about how fast the model responds, so average response latency is a key serving metric.

🔧 Debug

expert

Why does this NLP model serving code raise a KeyError?

Examine this snippet from a model serving function. Why does it raise a KeyError?

NLP

def serve_model(request_json):
    text = request_json['input_text']
    # Model prediction code here
    return {'prediction': 'positive'}

# Called with: serve_model({'text': 'Hello world'})

A The key 'input_text' does not exist in the input dictionary, causing KeyError

B The function is missing a return statement

C The model prediction code is incomplete and causes runtime error

D The input dictionary is empty, causing KeyError

💡 Hint

Check the keys used to access the input dictionary.

The function expects 'input_text' key, but the input dictionary has 'text' key, so accessing 'input_text' raises KeyError.

Practice

1. What is the main purpose of model serving in NLP?

easy

A. To visualize model training progress

B. To train NLP models faster

C. To collect more training data

D. To make NLP models available for real-time use

Solution

1. Step 1: Understand model serving concept

   Model serving means making a trained NLP model ready to answer requests instantly.

2. Step 2: Identify the main goal

   The goal is to provide real-time NLP results to apps or users, not training or data collection.

3. Final Answer:

   To make NLP models available for real-time use -> Option D

4. Quick Check:

   Model serving = real-time use [OK]

Hint: Model serving = ready for instant NLP predictions [OK]

Common Mistakes:

• Confusing serving with training
• Thinking serving collects data
• Assuming serving is for visualization

2. Which of the following is the correct way to serve an NLP model using a Python Flask API?

easy

A. import Flask
app = Flask(__name__)
@app.route('/predict')
def predict():
return 'Prediction result'

B. import flask
app = flask()
@app.route('/predict')
def predict():
return 'Prediction result'

C. from flask import Flask
app = Flask(__name__)
@app.route('/predict')
def predict():
return 'Prediction result'

D. from flask import Flask
app = Flask()
@app.route('/predict')
def predict():
return 'Prediction result'

Solution

1. Step 1: Check Flask import and app creation

   Correct import is from flask import Flask and app created by Flask(__name__).

2. Step 2: Verify route decorator and function

   Route decorator @app.route('/predict') and function returning string is correct.

3. Final Answer:

   Correct Flask API setup with proper import and app creation -> Option C

4. Quick Check:

   Flask import and app = Flask(__name__) [OK]

Hint: Flask app needs Flask(__name__) and correct import [OK]

Common Mistakes:

• Using wrong Flask import syntax
• Missing __name__ in Flask()
• Incorrect app creation call

3. Given this Flask code snippet serving an NLP sentiment model, what will be the output when accessing /predict?text=happy?

from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/predict')
def predict():
    text = request.args.get('text')
    if 'happy' in text:
        sentiment = 'positive'
    else:
        sentiment = 'neutral'
    return jsonify({'sentiment': sentiment})

medium

A. {"sentiment": "positive"}

B. {"sentiment": "neutral"}

C. Error: Missing text parameter

D. 404 Not Found

Solution

1. Step 1: Extract query parameter 'text'

   The URL provides text='happy', so text variable is 'happy'.

2. Step 2: Check condition for sentiment

   Since 'happy' is in text, sentiment is set to 'positive'.

3. Final Answer:

   {"sentiment": "positive"} -> Option A

4. Quick Check:

   Text contains 'happy' -> positive sentiment [OK]

Hint: Check if 'happy' in text to decide sentiment [OK]

Common Mistakes:

• Assuming neutral sentiment for 'happy'
• Forgetting to pass text parameter
• Confusing JSON string with Python dict

4. This Flask code for serving an NLP model throws an error. What is the bug?

from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/predict')
def predict():
    text = request.args['text']
    sentiment = 'positive' if 'good' in text else 'negative'
    return jsonify(sentiment=sentiment)

if __name__ == '__main__':
    app.run()

medium

A. Missing return statement in predict function

B. Using request.args['text'] causes KeyError if 'text' missing

C. Flask app is not created properly

D. jsonify() cannot accept keyword arguments

Solution

1. Step 1: Analyze request.args usage

   Using request.args['text'] raises KeyError if 'text' parameter is missing in URL.

2. Step 2: Identify safer alternative

   Using request.args.get('text') avoids error by returning None if missing.

3. Final Answer:

   Using request.args['text'] causes KeyError if 'text' missing -> Option B

4. Quick Check:

   request.args['text'] can cause KeyError [OK]

Hint: Use request.args.get() to avoid KeyError [OK]

Common Mistakes:

• Assuming request.args['text'] always exists
• Thinking jsonify can't take keywords
• Ignoring app creation correctness

5. You want to serve a summarization NLP model that sometimes returns empty summaries for very short texts. How can you improve the serving code to handle this edge case gracefully?

hard

A. Add a check to return the original text if the summary is empty

B. Always return an empty string for short texts

C. Raise an error when summary is empty

D. Ignore short texts and return null

Solution

1. Step 1: Identify the problem with empty summaries

   Empty summaries confuse users and reduce usefulness for short texts.

2. Step 2: Implement fallback logic

   Return the original text if the summary is empty to ensure meaningful output.

3. Final Answer:

   Add a check to return the original text if the summary is empty -> Option A

4. Quick Check:

   Fallback to original text if summary empty [OK]

Hint: Return original text if summary is empty to avoid blanks [OK]

Common Mistakes:

• Returning empty string confuses users
• Raising error breaks serving
• Ignoring short texts causes bad UX