> ## Documentation Index
> Fetch the complete documentation index at: https://docs.edgeimpulse.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Test Arduino VENTUNO Q and Edge Impulse with Qualcomm Device Cloud

> Train an image classifier in Edge Impulse Studio, then test it on a remote Arduino VENTUNO Q using Qualcomm Device Cloud without buying hardware

Created By: Haziqa Sajid

* Public Project Link: [https://studio.edgeimpulse.com/public/1131788/live](https://studio.edgeimpulse.com/public/1131788/live)
* Github repository: [https://github.com/haziqa5122/QDC-VENTUNO](https://github.com/haziqa5122/QDC-VENTUNO)

![Test Arduino VENTUNO Q and Edge Impulse with Qualcomm Device Cloud](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/header.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=0bb64e1625933ec9363193ddf79b1bda)

Before buying an Arduino VENTUNO Q, you may want to know whether your model will run well on its processor. Testing it can reveal accuracy and performance issues early. [Edge Impulse Studio](https://edgeimp.com/community26) lets you build an image classifier, while [Qualcomm Device Cloud (QDC)](https://qdc.qualcomm.com/) gives you remote access to a real Arduino VENTUNO Q for testing without owning the board.

You can upload test images, deploy your Edge Impulse model, and measure inference on the board’s Qualcomm processor and Hexagon NPU, all from your computer.

But remote access comes with a clock. Installing dependencies and downloading the model use the same session allowance as inference. The environment resets between sessions, and there’s no attached camera for collecting images or trying a live feed. Those limits shape how you should plan the build.

We’ll train a [three-class flower classifier](https://studio.edgeimpulse.com/public/1131788/live) in Studio, then run its full 90-image test set on the remote VENTUNO Q. Along the way, we’ll check the predictions and inference time, record the setup costs, and show where the no-hardware workflow needs extra work.

Get the companion scripts from the [QDC-VENTUNO GitHub repository](https://github.com/haziqa5122/QDC-VENTUNO) and refer to the [accompanying Edge Impulse project](https://studio.edgeimpulse.com/studio/1146836) for this tutorial.

## How the no-hardware workflow splits

The workflow uses three environments, each with a different role. Your computer stores and labels the dataset and prepares the files for upload. Edge Impulse Studio generates features and trains the classifier using cloud compute. Qualcomm Device Cloud (QDC) provides the timed hardware session for deploying the model and running inference on the VENTUNO Q.

You’ll need an Edge Impulse account and a Qualcomm ID to access these services. Node.js on your computer is only required if you use the optional packaging or scoring helpers. The board setup script installs Node.js and the Edge Impulse Linux CLI during the device session.

Because setup and model downloads consume QDC minutes, complete dataset preparation and training before opening the device session.

## Collecting and preparing the dataset

We used daisies, roses, and sunflowers from [TensorFlow Flowers](https://www.tensorflow.org/datasets/catalog/tf_flowers) for this build. You can use a different dataset. Choose labels that match what you want the model to recognize. The examples below show the three flower classes used in our classifier.

![Some Examples of the Dataset from TensorFlow Flowers](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image13.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=700860db08d7adc29540100a275dc3c0)

Collect your images locally or use an existing dataset, then upload them to Studio. Include different backgrounds, lighting, and angles, and aim for similar numbers of images in each class. A model that only sees neatly framed flowers may struggle with a cluttered scene.

Create an image-classification project in Studio. Under **Dashboard**, open **Project info** and check that Labeling method is set to One label per data item. Each image should have one class label, such as daisy, roses, or sunflowers.

Open **Data acquisition** and upload your images, assigning the appropriate class labels. Uploading one class at a time makes it easier to keep the labels consistent. The view below shows our labeled flower images, the training and test tabs, and a preview of the selected sample.

![Labeled flower images and the training/test split in Data acquisition](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image11.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=550ce9e54567e7e765b09cd0b63e263e)

Split the data into training and test sets before building the impulse. An 80/20 split is a useful starting point. Keep near-duplicates and images from the same capture session together so the test set checks unfamiliar examples. Our held-out set contained 90 images, with 30 per class.

Check the labels and class counts in **Data acquisition** before moving on. Keep the test set unchanged through training and board validation so you can compare the two runs fairly.

## Building and training the model in Studio

Set the target device to Arduino VENTUNO Q, shown in our Studio dropdown as Qualcomm QCS8275. The selector below shows the target used for this project.

![Setting the Target Device to Arduino Ventuno Q](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image5.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=eeff6c4896b7674f92448f3d6210ed83)

Under **Create impulse**, set the image width and height to 160 × 160 and choose **Fit** shortest axis as the resize mode. Add an **Image processing block**, followed by a **Transfer Learning** (Images) learning block, then save the impulse. The configuration below shows how the image input connects to these blocks and produces scores for daisies, roses, and sunflowers.

![The image-classification impulse with Image and Transfer Learning blocks](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image2.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=227bf945b2a1c82fdf7a0579b33d41bf)

With the impulse saved, open the Image block, select RGB color depth, and save the parameters. Keeping color gives the classifier another cue for distinguishing the flowers. The preview below shows the original sunflower image alongside its processed RGB input.

![RGB image processing parameters and the processed image](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image6.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=578cbf8589910123f0ae183a8160435e)

Open **Generate features** and generate features for the training set. The feature explorer below plots the processed images, with each point colored by its flower class.

![Generated image features in Studio’s feature explorer](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image12.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=72bd2a4b56f0242ce5c598212b5c2982)

In **Transfer Learning**, select [MobileNetV2 160x160 0.35](https://docs.edgeimpulse.com/studio/projects/learning-blocks/blocks/transfer-learning-images.md). We chose it as a compact starting point for this small, three-class dataset. Transfer learning reuses features from a pretrained network, letting us adapt the model to flowers with relatively few images. The 0.35 width multiplier keeps the network smaller than the full-width version, making it a useful baseline for measuring inference on VENTUNO Q.

For this run, set 30 training cycles and a learning rate of 0.0005, with data augmentation enabled. Augmentation adds variation to the training images to help the model handle changes in appearance. The screen below shows these training settings and the selected MobileNetV2 architecture.

![MobileNetV2 training settings for the three flower classes](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image8.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=3b3876f1780b0a72f22743d311a63f6b)

Click **Save & train** to start the job on Studio’s cloud compute. Our CPU training job took about three minutes and used no QDC time. Once it finishes, inspect the validation results before booking hardware. The panel below shows our quantized int8 model’s 93.1% validation accuracy and the errors across the three flower classes.

![Quantized int8 validation accuracy and confusion matrix in Studio](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image1.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=d99e988d1eb6c37918f082dcad6f0f8a)

Next, open **Model testing** and classify the held-out set. Studio reported 87.8% on our 90 test images using float32. Validation helps you tune the training job, while the held-out set checks images outside training. Save the model version and scoring settings with the results so the later hardware comparison means something.

## Spinning up the remote Arduino VENTUNO Q

Sign in to [Qualcomm Device Cloud](https://qdc.qualcomm.com) and find Arduino VENTUNO Q in the device catalog. VENTUNO Q is currently in Early Access on QDC, so request access before planning your device session. The catalog entry below shows its Early Access label and the available device minutes.

![Arduino VENTUNO Q in QDC’s Early Access device catalog](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image14.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=a183a3ddc673e655066bc907c8bba877)

The access form asks what you’re building, what you want to test on the board, and which dependencies you need. Submit the request before your planned validation session, then check the minute balance available to your account.

Choose SSH only because the setup and inference commands run in a terminal. Check the device’s access requirements and session options before starting. Have the upload package and SSH key ready when the board becomes available.

![VENTUNO Q device configuration in QDC](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image3.jpg?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=f46cb8fd16356a0e072297cdc2634efe)

![SSH-only access selected for terminal-based setup and inference; the browser-shell options are unavailable](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image7.jpg?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=7accea9c59e7a0aa34fceb681cdcb385)

Prepare the upload on your computer before starting the device session. Copy your held-out images into test-images/, then ZIP that folder together with board/, keeping both folders at the archive’s root. You can create this ZIP with your usual archive tool or use the optional packaging helper included with this project.

To use the helper, install Node.js on your computer and open a terminal at the project root, the folder containing board/ and local/.

Run the following two commands to install its dependencies and create the upload package:

```
npm ci --prefix local
node local/make-qdc-package.mjs
```

The first command installs the ZIP library required by the helper, using the dependency versions recorded in local/package-lock.json. The second runs make-qdc-package.mjs, which reads JPEG and PNG files from test-images/, adds the shell scripts from board/, and writes out/qdc-package.zip. It also converts the scripts to Linux line endings.

Inside the ZIP, `board/` contains four scripts:

* `00-ledger.sh`: Records setup and inference timestamps.
* `01-setup.sh`: Installs board dependencies and the Edge Impulse CLI.
* `02-connect.sh`: Downloads the compiled model from Studio.
* `03-batch-infer.sh`: Classifies the test images and saves results and timings.

The `test-images/` folder contains your held-out images. The compiled model is downloaded separately during the device session.

Open **Interactive Sessions** and click **New Interactive Session. Next,** add your ZIP through Package Upload. The Test Configuration screen below brings together the session time limit, connection mode, SSH key, upload package, and selected device.

![QDC’s Test Configuration screen for the VENTUNO Q session](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image4.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=dc23056aa4532d2b631c3cc1147bc0c6)

| **Setting** | **What to enter and why** |
| - | - |
| Session Name | Enter a recognizable name, such as VENTUNO Q flower validation, so you can find the session later. |
| Maximum Minutes Per Device | Set a 20-minute cap for this short validation run. The screenshot shows 120; change it to the limit you want. |
| Mode | Choose SSH only to connect from your computer’s terminal. |
| SSH Public Key | Use Generate Public Key or select an existing SSH public key. Keep the matching private key for the terminal connection. |
| Package Upload | Upload out/qdc-package.zip, or select a ZIP you already saved in QDC. It contains the board scripts and your test images. |

[Qualcomm’s FAQ](https://qdc.qualcomm.com/support/faq) says waiting for a device and platform setup aren’t counted. Charging starts when the session starts. Once running, connection troubleshooting and your own package installation use session time.

Click Connect and follow the [generated commands](https://qdc.qualcomm.com/support/user-guide/interactive-sessions/interact-with-devices/overview) in two terminals. Keep the tunnel open in the first and log in through it in the second. Use the session’s displayed credentials and host details. On Windows, restrict the downloaded private key’s permissions if OpenSSH rejects it, and replace /dev/null with NUL in the generated command.

Plan to collect the results and click **End Session** as soon as the run finishes. Closing your terminal leaves the QDC session running until you end it or its limit expires.

## Installing the Edge Impulse CLI on the board

The remote VENTUNO Q runs Ubuntu, so the setup follows the [Edge Impulse VENTUNO Q dependency instructions](https://docs.edgeimpulse.com/hardware/boards/arduino-ventuno-q.md): apt packages, Node.js 20, then the Edge Impulse Linux CLI through npm. Our setup script checks for an existing install and installs the missing dependencies.

Once the SSH connection is open, run the following commands in the remote VENTUNO Q’s shell. They prepare a working folder, record setup time, and install the Edge Impulse CLI.

First, create \~/qdc, copy the uploaded package into it, and enter its board/ folder. Check the upload folder in QDC’s file browser and adjust the copy path if necessary.

```
mkdir -p ~/qdc
cp -r /tmp/QDC_files/* ~/qdc/
cd ~/qdc/board
```

Next, load `00-ledger.sh` into the current shell and record session\_start. The leading dot makes its ledger command available; the timestamps go into `~/qdc/ledger.csv` so we can measure setup time.

```
. ./00-ledger.sh
ledger session_start
```

Run `01-setup.sh` to check for an existing CLI installation and install the board dependencies if needed. On Ubuntu, it installs the system packages, Node.js 20, and the Edge Impulse Linux CLI through npm. Then reload `~/.profile` so the current shell picks up the tools, and print the CLI version to verify the installation.

```
sh 01-setup.sh
. ~/.profile
edge-impulse-linux --version
```

A successful check prints the CLI version; our run used 1.25.2.

## Connecting the board and downloading the model

The runner needs your project API key to download the compiled model from Studio. For static-image inference, you can use the runner without configuring a camera for data collection. In Studio, Arduino VENTUNO Q (QCS8275) was selected as the hardware target; for this run, the model was deployed as Linux (AARCH64 with Qualcomm QNN). These selections serve different purposes: the former identifies the board, while the latter specifies a Linux deployment using Qualcomm's QNN backend. Edge Impulse also documents Arduino App Lab as a deployment route for VENTUNO Q.

![Linux (AARCH64 with Qualcomm QNN) deployment target for the compiled model](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image9.png?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=d4f199ba93d79f565cc53619b4a158ba)

Our download script authenticates with the project API key and saves the compiled .eim on the VENTUNO Q. From the board script folder, run:

```
EI_API_KEY=ei_your_api_key sh 02-connect.sh 
```

Choose `Quantized (int8)` when prompted. The script saves the model as `~/qdc/model.eim`, built for the board’s Linux target. Download and build took about 1.5 minutes in our recorded run.

Keep `~/qdc/model.eim` for the session and use it for each inference request. Confirm the download has finished before starting the test loop.

## Running inference on images

Use the held-out images you tested in Studio. Upload them with your session package or [QDC’s file browser](https://qdc.qualcomm.com/support/user-guide/interactive-sessions/interact-with-devices/compute-file-browser) and place them in \~/qdc/test-images/.

Start the runner’s HTTP server on the board to load the model once:

```
edge-impulse-linux-runner --model-file ~/qdc/model.eim --run-http-server 1337
```

Once it is ready, send an image from a second board terminal:

```
curl -s -X POST -F "file=@\$HOME/qdc/test-images/daisy.0000.jpg" http://localhost:1337/api/image 
```

The response contains class scores and timing. To classify the whole folder and save the results, run:

```
sh 03-batch-infer.sh ~/qdc/test-images
ledger session_end
```

Copy `results.txt` and `ledger.csv` from `~/qdc` to your computer, then click **End Session** in QDC. The ledger command records time. It does not end the session.

Our 90-image run took 13 seconds and classified 80 images correctly (88.9%). Classification took about 2 ms per image; the complete HTTP request had a median of 120 ms.

Studio scored 87.8% using `float32` and a confidence threshold. The board used int8 and the highest-scoring label, so the two accuracy figures are not directly comparable.

## Where the workflow breaks down

Training stays in Edge Impulse Studio. The remote VENTUNO Q runs the trained model, letting you check predictions and measure inference on real hardware.

A local webcam can supply images for remote inference. Capture JPEG frames on your computer and send them to the [runner’s image endpoint](https://docs.edgeimpulse.com/hardware/deployments/run-docker.md) through the QDC tunnel. This requires a capture client and port forwarding in addition to the static-image steps above.

QDC devices are [cleaned after ordinary sessions](https://qdc.qualcomm.com/support/faq), so prepare to install dependencies, upload your images, and download the model again. Keep the setup package ready before starting the session.

Remote inference confirms whether the compiled model runs on VENTUNO Q and measures its accuracy and speed on the supplied images. Camera quality, peripheral integration, and behavior under your application’s real operating conditions still need separate testing.

## What 1,000 minutes actually buys

Our VENTUNO Q access came with 1,000 free minutes, or 16 hours and 40 minutes of session time. Check the balance shown for your device before planning a run. Qualcomm [allocates minutes](https://qdc.qualcomm.com/support/faq) at the user or organization level, so the allowance available to you may differ.

The meter tracks session duration, so setup competes with inference for the same allowance. Our saved ledger covered 8.8 minutes of board setup and inference; allow extra session time for the tunnel and login. The measured breakdown was:

| **Phase** | **Recorded time** |
| - | - |
| Install dependencies and CLI | 3.6 minutes |
| Download and build model | 1.5 minutes |
| Runner troubleshooting between phases | About 3 minutes |
| Classify 90 images | 13 seconds |
| Ledger total, excluding earlier login | 8.8 minutes |

![QDC’s completed inference session records 30 minutes used. Our saved command ledger covers 8.8 minutes within that session](https://mintcdn.com/edgeimpulse/d0gsPqy4qhbJdIK7/.assets/images/what-you-can-build-without-hardware/image10.jpg?fit=max\&auto=format\&n=d0gsPqy4qhbJdIK7\&q=85\&s=e7912752ad3e01c0fedab49d2ee2bae0)

The three minutes spent getting inference working cost far more than the 13-second test itself. Use the recorded 8.8 minutes as a baseline for board setup and validation, then allow extra time for connecting, slow installs, and failed attempts. Pack several final model checks into one session when you can.

Train and inspect errors in Studio first. During one planned device session, validate the final candidates and save their outputs. A useful follow-up is to repeat the run in a new QDC session with additional test scenarios: different lighting, backgrounds, image sizes, and several final model builds. Use the same held-out images for a fair comparison between deployment routes. Keep a session cap, record configuration and latency for each run, and end the session explicitly. These additional tests are proposed, not completed results.

## Conclusion

QDC gives you a practical way to test a trained model on Arduino VENTUNO Q and other boards before buying them. We built the flower classifier in Edge Impulse Studio, then checked its predictions and inference time on the remote hardware using all 90 test images.

Finish training in [Edge Impulse Studio](https://edgeimp.com/community26) and prepare your files before opening the device session. Use that time to check how the model performs, save the results, and end the session. Cameras, peripherals, and your application’s operating conditions still need their own tests, but you can start that work knowing how your model behaves on the board. QDC lets you move from a trained model to real hardware validation before you buy a board.
