Model serving for NLP - ML Experiment: Train & Evaluate

Experiment - Model serving for NLP

Problem:You have trained a text classification model that can predict the sentiment of movie reviews. Now, you want to make this model available so others can send text and get predictions instantly.

Current Metrics:Model accuracy on test data: 88%. Model is saved but not yet served.

Issue:The model is not accessible for real-time predictions. Users cannot send text inputs and receive sentiment predictions through an API.

Your Task

Create a simple web API to serve the NLP model so users can send text and get sentiment predictions instantly.

Use Python and Flask for the API.

Load the saved model from disk.

Accept POST requests with JSON containing a text field.

Return JSON with the predicted sentiment label.

Keep the API simple and easy to understand.

Hint 1

Hint 2

Hint 3

Hint 4

Hint 5

Solution

NLP

from flask import Flask, request, jsonify
import joblib

app = Flask(__name__)

# Load the saved model
model = joblib.load('sentiment_model.joblib')

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    text = data.get('text', '')
    if not text:
        return jsonify({'error': 'No text provided'}), 400
    # Predict sentiment
    prediction = model.predict([text])[0]
    return jsonify({'sentiment': prediction})

if __name__ == '__main__':
    app.run(debug=True, port=5000)

Created a Flask web API with a /predict endpoint.

Loaded the saved NLP model using joblib.

Implemented POST request handling to receive text input.

Returned the model's sentiment prediction as JSON.

Added error handling for missing text input.

Results Interpretation

Before: Model was saved but not accessible for real-time use.

After: Model is served via a Flask API. Users can send text and get sentiment predictions immediately.

Serving a model through a simple web API makes it usable in real-world applications, allowing instant predictions on new data.

Bonus Experiment

Add input validation to check text length and reject empty or too long inputs.

💡 Hint

Use Python's len() function to check text length and return an error JSON if invalid.

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