# Export a computation and verify its serving contract
Phase 15: Deployment, interoperability & edge AI · about 110 minutes · CPU
## What you will be able to do
- Serialize and reload a fixed-shape JAX inference computation.
- Test known values and changed requests independently.
- Distinguish export compatibility from service and edge-device readiness.
## The problem
Your function works in the training process. Let’s make sure it also works after saving and reloading its inference computation. We’ll define one request shape, check a known prediction, and deliberately send an incompatible request. These checks give us a clear contract before adding a service around the model.
## The idea
Export packages a computation for a supported runtime. The consumer still needs input validation, preprocessing, output meaning and compatibility information. Separate the artifact boundary from the surrounding service.
## A serialized computation still needs an interface
The lesson exports a fixed float32 input of shape $(1,3)$ to an output of shape $(1,2)$. A Python function may accept a larger batch while that particular exported signature does not. The consumer must follow the artifact's declared contract.
Serialize, load the file again and call the restored computation on new inputs. Comparing only the original in-memory function does not test the exported bytes. Keep artifact hash, environment and tolerance with the result.
If preprocessing lives outside the export, version it alongside the model. A correct graph can still return wrong application results when the caller normalizes inputs differently. A local round trip does not automatically qualify another runtime, hardware target or version.
$$
\hat{y}_{\text{deserialized}}(x) = \hat{y}_{\text{eager}}(x), \qquad \forall x \in \mathcal{D}_{\text{canary}}
$$
### Four different deployment boundaries
**Predict:** Which row is tested by the exported object alone?
*Architecture and dataflow mechanism diagram.*
Read top to bottom from the raw request to the response. Each row has a distinct contract and a distinct failure. The exported computation handles the numeric call; request fields, artifact identity and response meaning require surrounding checks. The fresh-process experiment exercises loading and calling under the installed CPU runtime.
### Pause and reason
What should happen to a request with the wrong feature count?
Compare your reasoning
Reject it at the interface with a clear explanation before inference. Silently reshaping may alter example meaning and does not make the request compatible with the exported signature.
Reference solution
```python
# Exercise solution: Verify a new input [-2, 0, 3] against an independent NumPy expression.
changed = np.array([[-2., 0., 3.]], np.float32)
# Convert `expected` to a host NumPy array for inspection or verification.
expected = changed @ np.asarray(weights) + np.asarray(bias)
np.testing.assert_allclose(restored.call(changed), expected, atol=1e-6)
print("Changed exported request verified")
```
Hint
Validate shape and finiteness on the host before calling inference. Include a singleton batch, the wrong feature count and a NaN; specify which cases your serving signature permits.
Reference solution and reasoning
```python
# Validate a request before inference (Transfer): Validation belongs before the runtime call.
def validate_request(values):
# Convert `array` to a host NumPy array for inspection or verification.
array = np.asarray(values, dtype=np.float32)
# Guard input contract (`array.shape != (1, 3) or not np.isfinite(array).all()`) and fail fast if violated.
if array.shape != (1, 3) or not np.isfinite(array).all():
raise ValueError("expected finite float32 [1, 3]")
return array
for invalid in ([[1., 2.]], [[1., float("nan"), 3.]]):
try:
validate_request(invalid)
except ValueError:
pass
else:
raise AssertionError("invalid input accepted")
np.testing.assert_allclose(restored.call(validate_request([[1.,2.,-1.]])), [[3.1,-.45]], atol=1e-6)
```
Validation belongs before the runtime call. A dtype cast alone neither verifies input shape nor rejects NaNs.
Hint
Increment the counter only after validation succeeds. An error message alone does not prove which boundary rejected the input.
Reference solution and reasoning
```python
# Prove that request validation precedes exported inference (Transfer / diagnosis): The wrapper tests ordering as well as acceptance.
inference_calls = [0]
def checked_prediction(values):
array = validate_request(values)
# Accumulate the next contribution into `inference_calls[0]`.
inference_calls[0] += 1
return np.asarray(restored.call(array))
for invalid in ([[1., 2.]], [[1., float('inf'), 3.]]):
try:
checked_prediction(invalid)
except ValueError:
pass
else:
raise AssertionError('invalid request reached inference')
assert inference_calls[0] == 0
np.testing.assert_allclose(checked_prediction([[1.,2.,-1.]]), [[3.1,-.45]], atol=1e-6)
assert inference_calls[0] == 1
print('Invalid requests rejected before the one valid inference call.')
```
The wrapper tests ordering as well as acceptance. A service can satisfy an output check on valid inputs and still waste runtime work or fail unclearly on malformed requests.
Answer and explanation
The saved computation matches the tested CPU contract.
A successful round trip verifies the tested artifact and local runtime. Other consumers, device kernels and request systems require separate checks.