@@ -92,7 +92,7 @@ cd ../../..
 ### 4. Install Zephyr SDK
 
 ```bash
-west sdk install --gnu-toolchains arm-zephyr-eabi
+west sdk install --version 1.0.1 --gnu-toolchains arm-zephyr-eabi
 ```
 
 ### 5. Install Ethos-U tools (if targeting NPU boards)
@@ -194,4 +194,4 @@ When `CONFIG_ET_ARM_MODEL_PTE_DMA_ACCESSIBLE=y` is set in the board conf (which
 |-------|-----|--------|--------|
 | mps3/corstone300/fvp | Ethos-U55 | 512K ITCM + 2M ISRAM | hello-executorch (full), MV2 (build-only) |
 | mps4/corstone320/fvp | Ethos-U85 | 4M ISRAM + 2M SRAM | hello-executorch (full), MV2 (full) |
-| alif_e8_dk | Ethos-U55-256 | 4M MRAM + 2M SRAM | MV2 (model runs from MRAM in-place) |
+| ensemble_e8_dk/ae822fa0e5597ls0/rtss_hp | Ethos-U55-256 | 5.5M MRAM + 8M SRAM | MV2 (model runs from MRAM in-place) |
@@ -9,7 +9,8 @@ works on the Arm Corstone-320 FVP for development without hardware.
 
 - A quantized INT8 MobileNetV2 model with Ethos-U NPU delegation
 - A Zephyr RTOS application that loads the `.pte` model, runs inference on a
-  static test image, and prints the top-5 ImageNet predictions over UART
+  fixed input tensor, and prints the top-5 ImageNet predictions over UART
+- Optionally, classification of your own photograph (Step 7)
 
 ## Prerequisites
 
@@ -65,7 +66,7 @@ in its own source tree.
 Install the Zephyr SDK (compiler toolchain):
 
 ```bash
-west sdk install --gnu-toolchains arm-zephyr-eabi
+west sdk install --version 1.0.1 --gnu-toolchains arm-zephyr-eabi
 ```
 
 ## Step 3: Install ExecuTorch and Arm Tools
@@ -420,6 +421,62 @@ The reported inference time covers one `method->execute()` call, measured with
 outside that interval. For hardware comparisons, record the software versions,
 model, core/NPU configuration and clocks, and measurements over repeated runs.
 
+## Step 7: Classify Your Own Image
+
+The sample ships with a synthetic input tensor, which exercises the runtime but
+produces meaningless predictions. To classify a photograph, regenerate the
+input header:
+
+```bash
+python modules/lib/executorch/zephyr/samples/mv2-ethosu/gen_input.py your_photo.jpg
+```
+
+The script applies the resize and centre-crop that torchvision's default
+MobileNetV2 weights expect, and stores the result as uint8 RGB in NCHW order,
+matching the ImageNet normalisation the sample applies on device. It also records what float32 torchvision MobileNetV2 predicts for
+that image, so the device output has a reference to compare against.
+
+For that reference to mean anything, export with `--model_name=mv2` rather than
+`mv2_untrained`, and supply representative calibration data.
+
+`--calibration_data` takes a directory of `.pt` files, each holding one
+preprocessed input tensor of shape `[1, 3, 224, 224]`. Produce them with the
+same transform the model expects, so the quantized ranges reflect real images:
+
+```python
+import glob
+import os
+
+import torch
+import torchvision
+from PIL import Image
+
+images = sorted(glob.glob("my_photos/*.jpg"))
+os.makedirs("calib", exist_ok=True)
+
+weights = torchvision.models.MobileNet_V2_Weights.DEFAULT
+preprocess = weights.transforms()
+for i, path in enumerate(images):
+    x = preprocess(Image.open(path).convert("RGB")).unsqueeze(0)
+    torch.save(x, f"calib/{i:04d}.pt")
+```
+
+Then export against that directory:
+
+```bash
+python -m executorch.backends.arm.scripts.aot_arm_compiler \
+    --model_name=mv2 --quantize --delegate \
+    --target=ethos-u55-256 --calibration_data=calib \
+    --output=mv2_ethosu.pte
+```
+
+A few hundred images spread across classes is a reasonable starting point.
+
+Then rebuild and reflash as in Steps 5 and 6b.
+
+ImageNet has no "person" class, so portraits return an unrelated label with low
+confidence. Photographs of animals, objects, food and vehicles work well.
+
 ## Troubleshooting
 
 | Symptom | Cause | Fix |
 
@@ -16,8 +16,9 @@ produces are meaningless. To classify something real, regenerate the header:
 python gen_input.py your_photo.jpg
 ```
 
-The script resizes to 256, centre-crops to 224x224, stores the result as uint8
-RGB in NCHW order, and records what float32 torchvision MobileNetV2 predicts.
+The script applies the same resize and centre-crop that torchvision's default
+MobileNetV2 weights expect, stores the result as uint8 RGB in NCHW order, and
+records what float32 torchvision MobileNetV2 predicts.
 Rebuild and reflash after regenerating.
 
 Two things are required for that recorded prediction to be a valid reference.
@@ -29,10 +30,14 @@ calibrates on the model's example input, which is random:
 ```bash
 python -m executorch.backends.arm.scripts.aot_arm_compiler \
     --model_name=mv2 --quantize --delegate \
-    --target=ethos-u55-256 --calibration_data=<dir-of-pt-tensors> \
+    --target=ethos-u55-256 --calibration_data=calib \
     --output=mv2_ethosu.pte
 ```
 
+`--calibration_data` takes a directory of `.pt` files, each holding one
+preprocessed input tensor of shape `[1, 3, 224, 224]`, produced with the same
+transform the model expects (`MobileNet_V2_Weights.DEFAULT.transforms()`).
+
 ImageNet has no "person" class, so portraits return an unrelated label with low
 confidence. Photographs of animals, objects, food and vehicles work well.
 
 
@@ -12,10 +12,11 @@
 
     python gen_input.py cat.jpg
 
-The image is resized to 256, centre-cropped to 224x224 and stored as uint8 RGB
-in NCHW order, matching the normalisation main.cpp applies on device. The
-float32 torchvision prediction is recorded in a comment so the device output
-has a reference to be compared against.
+The image is resized and centre-cropped using the preset that ships with
+torchvision's default MobileNetV2 weights, then stored as uint8 RGB in NCHW
+order. The same weights produce the float32 prediction recorded in a comment,
+so the device output has a reference to be compared against. Normalisation is
+applied on device by main.cpp.
 
 Requires: pillow, torch, torchvision.
 """
@@ -38,18 +39,37 @@ def main() -> None:
     parser.add_argument("-o", "--output", default=HEADER, help="header to write")
     args = parser.parse_args()
 
-    weights = torchvision.models.MobileNet_V2_Weights.IMAGENET1K_V1
+    # Match examples/models/mobilenet_v2, which exports MobileNet_V2_Weights.DEFAULT.
+    # Resize and crop are taken from the weights so this cannot drift if the
+    # default checkpoint changes.
+    weights = torchvision.models.MobileNet_V2_Weights.DEFAULT
     model = torchvision.models.mobilenet_v2(weights=weights).eval()
     categories = weights.meta["categories"]
 
-    crop = transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224)])
+    preset = weights.transforms()
+    resize_size = preset.resize_size[0]
+    crop_size = preset.crop_size[0]
+
+    crop = transforms.Compose(
+        [transforms.Resize(resize_size), transforms.CenterCrop(crop_size)]
+    )
     normalize = transforms.Compose(
         [
             transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            transforms.Normalize(mean=preset.mean, std=preset.std),
         ]
     )
 
+    # main.cpp applies these constants on device; bail out if the weights
+    # ever move to a different normalisation.
+    device_mean = [0.485, 0.456, 0.406]
+    device_std = [0.229, 0.224, 0.225]
+    if list(preset.mean) != device_mean or list(preset.std) != device_std:
+        raise SystemExit(
+            f"weights expect mean={list(preset.mean)} std={list(preset.std)}, but "
+            f"main.cpp applies mean={device_mean} std={device_std}; update both."
+        )
+
     image = crop(Image.open(args.image).convert("RGB"))
     with torch.no_grad():
         logits = model(normalize(image).unsqueeze(0))[0]
@@ -71,9 +91,9 @@ def main() -> None:
         " * LICENSE file in the root directory of this source tree.",
         " *",
         f" * Generated by gen_input.py from {os.path.basename(args.image)}.",
-        " * Resized 256, centre-cropped 224, uint8 RGB in NCHW order.",
+        f" * Resized {resize_size}, centre-cropped {crop_size}, uint8 RGB in NCHW order.",
         " *",
-        f" * float32 torchvision MobileNetV2 predicts class {top1} "
+        f" * float32 torchvision MobileNetV2 ({weights.name}) predicts class {top1} "
         f"({categories[top1]}) at {probs[top1].item() * 100:.1f}%.",
         " */",
         "",