Saving & Deploying a Model

Training is once; predicting is forever

Every script so far trained a model and threw it away when the program ended. That is fine for learning, but useless in the real world. In production you train once, then save the model and load it again to make millions of predictions — without ever retraining. A model that only lives in your notebook cannot help a real user.

Going from “a model in memory” to “a model real users can call” is called deployment. It has two parts: saving the trained model to a file, and serving it behind something a user or another program can talk to (usually a small web app).

Step 1 — save the trained model to a file

A trained scikit-learn model is just a Python object, so we can save it to disk and load it back later, fully trained. The standard tool is joblib (it handles the large number arrays inside models better than plain pickle).

import joblib
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
model = RandomForestClassifier(n_estimators=100, random_state=0)
model.fit(X, y)

joblib.dump(model, 'iris_model.joblib')   # save the trained model
print('Saved iris_model.joblib')

Anywhere else — another script, a server, next week — you reload it with one line and predict immediately, no retraining:

import joblib

model = joblib.load('iris_model.joblib')   # load the trained model back
print('Prediction:', model.predict([[5.1, 3.5, 1.4, 0.2]])[0])

Step 2 — serve it behind a tiny web app

To let other programs (a website, a phone app) get predictions, you wrap the model in a small web server. The lightest way is Flask: it turns a Python function into a web address (an API endpoint) that takes input as JSON and returns the prediction as JSON. JSON is just the standard text format programs use to swap data.

Here is a complete, minimal prediction server. It loads the saved model once at startup, then answers every request.

from flask import Flask, request, jsonify
import joblib

app = Flask(__name__)
model = joblib.load('iris_model.joblib')   # load once at startup

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()              # e.g. {"features": [5.1, 3.5, 1.4, 0.2]}
    features = [data['features']]
    species = int(model.predict(features)[0])
    return jsonify({'species': species})

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

With that server running, any program can ask it for a prediction by sending JSON to the /predict address. From a terminal you might test it like this:

curl -X POST http://localhost:5000/predict \
     -H "Content-Type: application/json" \
     -d '{"features": [5.1, 3.5, 1.4, 0.2]}'

The full picture

1. Train the model on your data (once).
2. Save it with joblib.dump to a .joblib file.
3. In a Flask app, joblib.load the file once at startup.
4. For each request, read the input JSON, call .predict(), return the result as JSON.
5. Deploy that app to a host (Render, Railway, a cloud VM) so it is reachable on the internet.

For a quick demo with a built-in user interface instead of a raw API, Streamlit is even simpler — a few lines turn your model into a web page with input boxes and a result, no front-end code. It is the fastest way to show a model off in a portfolio.