XII — Review real experiment Runs in VS Code

Watch the Academy video — 6:22.

Train two decision trees on the UCI Wine dataset, then review their measured results in Apizr for VS Code. The dataset contains 178 real wine samples, 13 chemical measurements and three cultivar classes; it is bundled with scikit-learn. Credit: S. Aeberhard and M. Forina, Wine (1992), CC BY 4.0.

The images show the actual 0.4.6 development extension and locally executed Runs.

1. Prepare the example

Use a checkout of Apizr's 0.4.6 development branch, Python 3.14, uv and the development VSIX. From the repository root, copy the example into a fresh directory:

cp -R examples/tracking/wine-vscode /tmp/apizr-wine
uv venv /tmp/apizr-wine/.venv --python 3.14
uv pip install --python /tmp/apizr-wine/.venv/bin/python \
  '.[notebook]' -r /tmp/apizr-wine/requirements.txt
cd /tmp/apizr-wine
.venv/bin/apizr init .
.venv/bin/python wine_experiments.py

This installs the selected development checkout. The scientific dependencies belong to the example's environment, independently of the extension's managed CLI.

The script exports the dataset to wine.csv, uses the same stratified 70/30 split and seed 42, and executes trees with max_depth=1 and max_depth=3. Each SDK session records the input's content identity, the two parameters and the computed accuracy and macro F1, rounded to four decimal places before logging.

2. Connect the extension

The policy created by init allows source inspection. Add read access to this project's history and select the example's Python environment:

.venv/bin/python - <<'PY'
import json
from pathlib import Path

root = Path.cwd().resolve()
policy = root / ".apizr/operator.json"
document = json.loads(policy.read_text())
document["grants"].append({
    "adapter": "experiments", "operation": "history.read",
    "target": {"kind": "local", "root": str(root)},
    "store": ".apizr/experiments/v1", "permissions": ["experiments.read"],
})
policy.write_text(json.dumps(document, indent=2) + "\n")
(root / ".vscode").mkdir(exist_ok=True)
(root / ".vscode/settings.json").write_text(json.dumps({
    "apizr.engine.mode": "python",
    "apizr.engine.python": str(root / ".venv/bin/python"),
    "apizr.operatorPolicy": str(policy),
}, indent=2) + "\n")
PY
code .

Trust this example folder, then run Apizr: Check engine. Open the Apizr bee, choose Open experiment dashboard, then Refresh history. Opening the view alone does not start an engine or load the store.

The captured session contains the two SDK Runs plus a real Jupyter Run from step 5. Run identities and timestamps will differ in your own session.

3. Read a Run

Select a Run's digest in the dashboard. Read its capture mode, max_depth, random_state, accuracy and macro_f1. Open complete JSON preserves the canonical Plan and Run, including input fingerprints and unknown evidence. Open recorded source opens the current source file.

This short GIF sequences captured views of the running extension:

In the captured execution:

Capture	max_depth	Accuracy	Macro F1
SDK	1	0.6111	0.4846
SDK	3	0.9630	0.9638
Jupyter	5	0.9630	0.9638

These are observations on one held-out split. Depths 3 and 5 give the same scores here. This comparison does not establish performance on another dataset or approve a deployment.

4. Inspect and compare

Open wine_experiments.py and choose Apizr: Inspect with Apizr. Expand the Inspection view to follow the engine's evidence and source locations. Inspection reads saved source; it does not fit a model. Editing the file marks that evidence outdated until you explicitly inspect the saved file again.

Choose Compare two Runs, selecting the depth-1 SDK Run as A and the depth-3 SDK Run as B. Read the observed parameter change, the Wine input identity and the metric deltas in the canonical comparison. Reverse A and B to reverse the deltas. Unknown evidence remains unknown.

5. Add a real notebook Run

Open wine_review.ipynb in a Jupyter-capable editor, select the example's .venv kernel and execute its two code cells. The last cell fits the depth-5 tree and logs its measured scores through the same function and history store. Refresh history to see its Jupyter capture mode alongside the SDK Runs.

Apizr does not install or replace a notebook kernel. Its notebook-toolbar inspection action reads the saved notebook without executing any cells. A cell identity and execution count do not describe every value in live kernel memory; continue with the Jupyter tracking lesson for that distinction.

Try it: repeat the depth-5 cell. Confirm that another Run appears with a new identity and execution count. Compare its scores and retained input identity with the previous execution before drawing a conclusion.

Extension settings and limits · Tracking guide · Example source