Saving the Whole Prediction Procedure

Botie saves a model’s weights and loads them tomorrow. The code runs, but predictions change because the new process prepares inputs differently.

Suppose we save the model weights but forget the training mean used to centre its inputs. We can reload the weights and still get different predictions. We need to save the fitted preparation alongside the model, with a description of the expected features. Then we can check whether the loaded procedure reproduces known examples.

Prepared row: [1, 1]
Saved weights: [3, −1]
Saved intercept: 2
Prediction = (1 × 3) + (1 × −1) + 2 = 4

The training reference and model coefficients are both part of the fitted procedure. Change an incoming value and apply those retained quantities in the original order.

4

A standardising linear predictor needs feature names and order, training means, positive scales, weights, and intercept. A categorical pipeline may also need vocabulary, unknown-category rules, and imputation values.

Distinguish fitted values from configuration. Both matter for reproducibility, but fitted values must come only from the training partition.

Keep units and preparation order with the state rather than relying on memory.

On a new record, subtract the saved training mean and divide by the saved scale. Do not calculate a fresh mean from each request. That would make the prediction depend on what other records arrived in the batch.

x = [12,25]
Saved mean = [10,20]; scale = [2,5]
Prepared x = [1,1]
Prediction = dot([1,1], [3,-1]) + 2 = 4

Inference transforms with retained state; fitting estimates that state.

For this simple model, JSON can store lists, numbers, feature names, and a schema version. Convert lists back to arrays when loading and validate their shapes and finiteness.

For larger arrays, an array format can be more suitable. Do not load untrusted pickle-based objects: deserialisation can execute code. An artifact format and runtime compatibility policy are part of the system design.

The example round-trips an in-memory JSON string so no filesystem or service setup is needed.

import numpy as np
raw = 12.0
saved_mean, saved_scale = 10.0, 2.0
weight, bias = 3.0, 1.0
prepared = (raw - saved_mean) / saved_scale
print(prepared)
print(prepared * weight + bias)
print(raw * weight + bias)

1.0
4.0
37.0

Retain several representative input-output examples, including boundary cases. Compare the original and loaded procedures within a declared tolerance. Also check feature order, runtime versions, and any unsupported operations.

Exact agreement on fixtures does not prove identical behaviour for every input, but it catches common omitted-state and ordering failures before deployment.

Botie’s workshop shows the full numerical pipeline from raw record to prediction.

A linear predictor may need a feature order, units, imputation values, category vocabulary, scaling statistics, weights and an intercept. Some came from fitting; others came from the input contract. Both affect the answer.

Give the artifact a schema version. A loader should know which fields that version requires and reject unsupported versions explicitly. A model name alone does not specify how an incoming record becomes the array the weights expect.

Serialising a model is not finished when a file is written. Load the saved representation into a new object, reconstruct its numerical arrays and run fixtures that exercise more than one input.

Keep these fixtures separate from the training objective. They test that storage and loading preserve the procedure, not that the model generalises.

import numpy as np
import json
artifact = {'schema': 1, 'features': ['temperature','humidity'], 'mean': [10.,50.], 'weight': [2.,.1], 'bias': 3.}
restored = json.loads(json.dumps(artifact))
X = np.array([[12.,60.],[10.,50.]])
def predict(model, X):
    return (X-np.array(model['mean']))@np.array(model['weight'])+model['bias']
print(predict(restored, X).tolist())
print(bool(np.allclose(predict(artifact,X), predict(restored,X))))

[8.0, 3.0]
True

A saved representation may depend on library conventions, numerical precision or custom preprocessing code. Record the runtime and code version needed to interpret it. Test a fresh process rather than relying on imports and variables left in a notebook.

For the small model here, an inspectable JSON schema is sufficient. More complex models may require another format. Only load trusted executable serialisations; plain numerical formats reduce that need but still require schema and size checks.