docs/tools: add Edge Impulse and Roboflow training-service guides

New "Model training services" caption in the Tools chapter, between
External libraries and Calculators.

- edge-impulse.rst: single page covering the OpenMV-specific path --
  capture data with the IDE, train an image classifier or FOMO
  model, deploy via the OpenMV Library, load through ROMFS. Leads
  with the Edge Impulse product-overview video (Vimeo embed); links
  their OpenMV board-setup and run-on-OpenMV guides.
- roboflow/: a six-page walkthrough (index + create-project,
  upload-footage, label, train, deploy, wrap-up) built from the
  OpenMV+Roboflow demo video, captioned in three groups. Seven
  workflow screenshots pulled from the video; index leads with
  Roboflow's homepage hero clip. Recommends Roboflow 3.0 (YOLOv8)
  decoded by ml.postprocessing.ultralytics, deployed via the OpenMV
  3rd-party target and loaded through ROMFS.

Both pages written in the reference-tutorial voice (direct,
concrete, no meta-narration or editorializing).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: kwagyeman

docs/openmvcam/tutorial/tools/edge-impulse.rst

@@ -0,0 +1,76 @@
+Edge Impulse
+============
+
+.. raw:: html
+
+   <div style="position: relative; padding-bottom: 56.25%; height: 0;
+               margin-bottom: 1.5rem; overflow: hidden; border-radius: 8px;">
+     <iframe src="https://player.vimeo.com/video/832261155?title=0&amp;byline=0&amp;portrait=0"
+             style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 0;"
+             allow="autoplay; fullscreen; picture-in-picture" allowfullscreen
+             title="Edge Impulse Product Overview"></iframe>
+   </div>
+
+`Edge Impulse <https://edgeimpulse.com/>`__ is an end-to-end
+platform for building machine-learning models that run on
+microcontrollers: collect and label data, design and train a model
+in the browser, and have it optimized to fit a device measured in
+kilobytes. It deploys straight to OpenMV -- a few clicks turn a
+trained model into files ready to run on the camera. Edge Impulse's
+own `documentation <https://docs.edgeimpulse.com/>`__ goes deeper on
+every step.
+
+Getting data in
+---------------
+
+A model performs best on the kind of images it was trained on, so
+capture the dataset with the camera that will run it. The IDE's
+:doc:`dataset editor <ide/dataset-editor>` is built for exactly
+this -- create class folders, capture labelled images from the live
+frame buffer, and then upload the dataset straight into an Edge
+Impulse project from the Export submenu (log in to your account
+there first). From that point on you work in Edge Impulse Studio.
+
+.. seealso::
+
+   Edge Impulse's own `OpenMV Cam setup guide
+   <https://docs.edgeimpulse.com/hardware/boards/openmv-cam-h7-plus>`__
+   for installing the tools and connecting the camera.
+
+Training
+--------
+
+Training happens entirely in the browser: design an *impulse* (the
+input, processing, and learning blocks), train it, and check the
+accuracy on the held-out test data.
+
+Two model types suit the camera. An image classifier outputs a list
+of class scores, which you read straight off the model's output --
+no post-processor needed. FOMO, a fast object detector designed for
+microcontrollers, needs one decoding step, and the camera ships a
+post-processor for it (:mod:`ml.postprocessing.edgeimpulse`), so
+those models run with no extra code either.
+
+Deploying to the camera
+-----------------------
+
+When training finishes, open the project's **Deployment** page,
+pick the **OpenMV Library** target, and click *Build*. The download
+is a zip holding the trained model (``trained.tflite``), its labels
+(``labels.txt``), and an example script. The model is
+integer-quantized. Edge Impulse covers this and the
+custom-firmware alternative in its `run on OpenMV guide
+<https://docs.edgeimpulse.com/hardware/deployments/run-openmv>`__.
+
+Add the ``.tflite`` file to the camera with the IDE's :doc:`ROMFS
+editor <ide/romfs>`, which converts it for the board's NPU when it
+has one, and load it in a script with ``ml.Model``. Models also run
+from the camera's flash drive -- copy the files over and point
+``ml.Model`` at the path -- but ROMFS is the better home: models
+there execute straight from flash without a RAM copy.
+
+.. seealso::
+
+   The :doc:`machine learning chapter <../ml/index>` for running
+   models with the :mod:`ml` module -- loading, the inference
+   pipeline, and decoding the output.

docs/openmvcam/tutorial/tools/index.rst

@@ -22,6 +22,13 @@ it, or help size the system around it.
    arduino-rpc/index.rst
    micropython-tools.rst
 
+.. toctree::
+   :caption: Model training services
+   :maxdepth: 1
+
+   edge-impulse.rst
+   roboflow/index.rst
+
 .. toctree::
    :caption: Calculators
    :maxdepth: 1

docs/openmvcam/tutorial/tools/roboflow/create-project.rst

@@ -0,0 +1,31 @@
+Creating a project
+==================
+
+From the Roboflow workspace, **New Project** opens the create page.
+A project bundles a dataset, the models trained on it, and their
+deployment targets.
+
+.. figure:: figures/create.jpg
+   :width: 100%
+   :alt: Roboflow's "Let's create your project" page: project name field, visibility and license options, and the project-type list with Object Detection selected
+
+   The create-project page, with **Object Detection**
+   chosen as the project type.
+
+Two choices matter here:
+
+* **Project Name.** Use anything memorable -- this example uses
+  ``Finding raccoons``. The name becomes part of the model's
+  identifier, which you download at the deploy step.
+* **Project Type.** This sets what the model predicts, so match it
+  to what you want the camera to do. **Object Detection** -- finding
+  objects and their positions with bounding boxes -- is the one for
+  locating things in the frame, and it is what the camera's YOLO
+  post-processors decode. The other types -- classification,
+  instance segmentation, keypoint detection -- train different model
+  heads; this example uses object detection.
+
+The visibility and license options affect only whether the dataset
+is shared publicly on Roboflow Universe -- they have no bearing on
+the model that ends up on the camera. Set them as you like, then
+**Create Project**.

docs/openmvcam/tutorial/tools/roboflow/deploy.rst

@@ -0,0 +1,45 @@
+Deploying to the camera
+=======================
+
+The trained model lives on Roboflow's servers. Getting it onto the
+camera takes one download, then the same steps as loading any other
+model.
+
+Downloading the weights
+-----------------------
+
+On the **Deployments** page, choose **Deploy to 3rd Party
+Platforms** and select the **OpenMV** tab. It downloads the model's
+weights as a single integer-quantized ``.tflite`` file, named after
+the project and version -- the int8 format the camera's TFLite
+engine runs.
+
+.. figure:: figures/deploy.jpg
+   :width: 100%
+   :alt: Roboflow's "Deploy to 3rd Party Platforms" dialog with the OpenMV tab selected and a Download Files button
+
+   The OpenMV deploy target -- **Download Files** saves
+   the camera-ready ``.tflite`` weights.
+
+Loading it on the camera
+------------------------
+
+Add the ``.tflite`` file to the camera with the IDE's :doc:`ROMFS
+editor <../ide/romfs>`, which converts it for the board's NPU when
+the board has one, then load it in a script with ``ml.Model``.
+Models also run from the camera's flash drive -- copy the file over
+and point ``ml.Model`` at the path -- but ROMFS is the better home:
+models there execute straight from flash without a RAM copy.
+
+A detection model's raw output is a tensor of box coordinates and
+class scores that still needs decoding. Roboflow's YOLO-family
+detectors decode with the post-processors the camera ships in
+:mod:`ml.postprocessing.ultralytics`, so a few lines wire the model
+to its decoder and you have boxes and labels.
+
+.. seealso::
+
+   The :doc:`machine learning chapter <../../ml/index>` for running
+   models with the :mod:`ml` module -- loading, the inference
+   pipeline, and the :doc:`walkthrough of decoding YOLO-family
+   output <../../ml/postprocessing/yolov8-walkthrough>`.