# How to Use the Sample App

In this tutorial we will walk you from start to finish getting a model working with the QNN Sample App. The Sample App provides a reference implementation for how to use the QNN API to execute inferences on your target device with your model. After you understand how to build the app and use it, you can use its implementation as a starting point for allowing your own on-target application to interact with your model.

The recommended developer flow is:

1. Follow these steps to prove you can:

    1. Execute your model on the target device.
    2. Build and use an app on your target device.
2. Adapt sections of the Sample App into your on-device application for your use case (or add your own logic to expand the Sample App based on your needs).

    1. You should read the code in the Sample App to understand what is going on. You can use the API docs to identify how you can change the code for your use case.

This tutorial as a whole is designed to show you how to use QNN across different host devices, target devices, and situations. In order to provide actionable commands for all of those paths, this tutorial is structured like a “choose your own adventure” where you will frequently be able to choose the steps that are relevant for your situation.

Note

Throughout this tutorial, we frequently use commands and environment variables to help you take the right actions. If any command does not work for you, we recommend you copy it and any errors into an AI chat of your choosing and ask the AI to explain what the command is doing and why it was not working for you.

Before you start taking actions, it’s important for you to note down the configuration(s) you want to support. Having those written down ahead of time will help you choose the right paths through this tutorial for your situation. You can also use the default configuration (underneath these questions) if you aren’t sure yet what configuration you want.

## Questions to Answer

Warning

If you don’t know what answers to give, you can skip past these questions and use the default configuration underneath.

1. What AI model do you want to use?

    1. Qualcomm’s software allows you to work with your own models, or use models from various popular frameworks. You can also explore [Qualcomm’s AI Hub](https://aihub.qualcomm.com/) to find models for your use case.
    2. Example model: [EfficientNet Lite](https://github.com/onnx/models/tree/main/validated/vision/classification/efficientnet-lite4/model)
2. Which AI framework is the model using?

    1. You can usually tell what framework a model was built with by looking at the file extension of it.
    2. Ex. [ONNX](https://onnx.ai/) (`.onnx`), [Tensorflow](https://www.tensorflow.org/) (`.pb`, `.tflite` for TensforflowLite format), [PyTorch](https://pytorch.org/) (`.pt`) etc.
3. What is the architecture and OS of your host machine?

    1. You can run the following commands to learn more about your device:

        1. On Linux: `uname -a` for architecture and `cat /etc/os-release` for the OS.
        2. On Windows: `systeminfo` for architecture and `Get-ComputerInfo | Select-Object WindowsProductName, WindowsVersion, OsArchitecture, OsName` for the OS.
    2. Ex. `x86_64` `Ubuntu 22.04`
4. What is the architecture and OS of your target device?

    1. See the previous question for commands you can run to investigate this.
    2. Ex. `ARM 64` `Android`
5. Which processor(s) on the target device do you want to use for your AI models? (Ex. CPU, GPU, HTP, DSP, etc.)

    1. This choice is mostly based on the specs of your target device and what processors it has available.
    2. Ex. `CPU`

## Default Configuration

You can use this to experience the QNN workflow for running inferences with a model on a target device:

1. Model: [EfficientNet Lite](https://github.com/onnx/models/tree/main/validated/vision/classification/efficientnet-lite4/model)
2. Framework: ONNX
3. Host machine architecture and OS: Use your current dev computer (either Linux or Windows, there is no support for Mac as a host machine)
4. Target device: The same as your host device (testing locally)
5. Processor(s): CPU

Note

When you are presented with choices going forward, refer back to your answers to these questions.

## Final Notes Before Starting

Warning

As of now, the steps in this guide are written primarily for a Linux host machine. These are still the right sequence of steps for Windows. To use this with a Windows machine, you should:

1. Use [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) to be able to use linux-style commands. Alternatively, you can use an AI chat along with the below rules to adapt commands to Powershell equivalents - the overall flow will be equivalent.
2. Follow the [Windows Setup](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/windows_setup.html) steps before any of these steps.
3. Use `.dll` equivalents of any `.so` file. Note: The filename will be different, as the Linux equivalents normally start with `lib`, while the Windows ones do not.
4. Use `qnn-sample-app.exe` instead of the `qnn-sample-app`.

Note

Keep in mind that all steps below are **required** unless they explicitly say they are “(optional)”.

## Part 0: Configuring Your System

This section is required to ensure you have the proper permissions, software, and environment variables to work with the QNN SDK and API.

Note

Step 3 below defines an aliased function `setenvvar` that we will use extensively throughout this tutorial to set, log, and persist the values across terminal sessions, so ensure you follow those steps.

- **Step 1:** (Optional, but recommended) Create a user with proper permissions

    This step helps you create a non-privileged user with access to `sudo`. While you don’t *need* a custom user, it is recommended to avoid giving installation scripts privileged access. The other advantage to creating this user is it makes a clean workspace you can access anytime with only files relevant to your QNN development. We will call the user we create `qnn`.

    - **Step 1.1:** Create `qnn` user, adding it to the `sudo` group at the same time

sudo useradd -mUs $SHELL -G sudo qnn
            Copy to clipboard
    - **Step 1.2:** Set the `qnn` user’s password

sudo passwd qnn
            Copy to clipboard
    - **Step 1.3:** Login to the `qnn` user

        You’ll need to run this command every time you want to login to the `qnn` user for QNN development.

su -l qnn
            Copy to clipboard
- **Step 2:** Download and extract the [Qualcomm QNN SDK](https://www.qualcomm.com/developer/software/neural-processing-sdk-for-ai)

    In order to work with QNN, you’ll need the SDK. The steps below detail how to obtain and extract it.

    - **Step 2.1:** Visit the [Qualcomm QNN SDK](https://www.qualcomm.com/developer/software/neural-processing-sdk-for-ai) website.
    - **Step 2.2:** Right-click the “Get software” button, and click “Copy link” (or a similar button).

![Right-click the Get software button and copy the link.](data:image/png;base64,UklGRnQ2AABXRUJQVlA4TGc2AAAvpYJgABWLwrZtG1n/f52kCz0gIiaA24lh2f7MvorqE7czF28GldXCubAuoPKk8yOAHIm6djXQWdJ4lu3Ei3sgKofj0u3Q+0AY03lzYexAHuzOP7VYkPPh2fR4L9Uk1uRKDd8X06ztqiPL+RsNZmZ2+Q5rWMMemaGZoXrmkaOGNzy6MzOzR8zMzMzMzEx7f3vrSLnvkfa+jNmQEScHskzZSke6QqOrMzsRDTqRzVQXmmS2M7ch0xp1nJvluKEy5OneDSeiSWnWMduZHenI5taujIyQZdJFmY8hb+wOGWRQme3mLAPTRpIcFbz8o/oAzjyy6ODDeQOg1rb1LNrk1wESJA4cSCTyU6wc5C/JTAnIT04Jv/zklBCL6j8sSLalNHMe8HgsThYsE+HJt+Xn/x63cf6NHJk+MBThjUMHPPLII49M55FHHnXkkUemM51HHnnUkUfewlPA9O2r9O296X1fDmkuPOm9uhy4AFPcML4Z8O6OCzCpnOU2ZdMpCHG2EtkmL7Bu8IrpMQR5UrQpxkwsAbLSmLJVAVN/LoDxpksbhEoVt4lbmcL0XrdJlSXJtpUl+X+FfMORVx55JfIqojkMOzpQLVsWz5AiAYwjOXJudnIWu2Zu52Zu2LBhI5fqKumyLgsOvHwDBw5cuNDZDRc62x9yVf8lQbIdNUw/i1VWdAAHszg565n+f3IcyXkre0lqkyZNmm2OOSbNNdtsc8wyx6Q5Js02adJss80x29T1AsbO/wF0FVtEQxd0AjoLuoA9GJUTVAR+VpfObOsbUTT+a0EnEHQKDhGoCapSJ7BnpZUdSQPzBhDLnyKgqwt7EAGr/uRuRAG6KnsYgdyzdKOHcpk6GxaiuAeYtpEkyflHuHDgwoF1D4Bi25YV5zq2zD9xMISSLZFIZMuSkciWkZElMwQkElkyv0H1XxZkW2HbnGfJkYyUQwuaZ6RY/r4CL85L8LJcXJu7cw83HwIeAR4NtgKPAU8A24Edwc5gV7Ab2APsCfYCe4M37gM69wV0HuvB3Wx+63d7sJniwV4O3c8SAGyNbvH/+83+/byXNZiQcwWuyCWRFxFPoM3X9Kc9XAQ8AmwGpjSBxwNN2wkoRCrFI+KJwb/obkZ8WDVpgLOZ+ZA3MEHbCbcjV5u4kBDmt+OwFJDE4WuGu3fLGvjzKfpTh0vG3ofX4RXhcyKcQ8dpBrMCSmtMUs5VQqLd4MzxduY81GqCzGzGAYATa2r08sHNLta+eMNnFEWv9f2mj/v27olm71TOtxNPXAsnnhiUqH0lUGrr0JzHEe9jPHveONBljImqVTzvQ+Bx5DA0Gw0al2Y1IO8MvumNkqI0ymrGYqrWMqp6Gqjqzf7+WkfRdat93I1ePXr+Wt/Rc/tEVW9QVfVyUNWAgl2gqmDYUUNUaLpscUXvYdUqMxyOC3XLDlY0m0SQpjkd6xYTQsWf0QsPVi/gmTmOXt23djeK7qsLtLPUzITWU/vVPq1pumwxfsnkclUY4BS6Q9DgXdEva5o2outhgbgcANxMPZjHiycPrbWPo+jtSiYOVj+kNXHYUHUZK8vlqijAIXb7xU1FF3GTV7iph3Bm+lnEQsxL1HW8VdIvdbuqPfgkiu5kIEm/SfeVWtNUXcZSHe5I3RQGeJRNBp+KhUJB13Uvjs+LbhR9mAX0XqE1eBQW6U8rIrt8CAN80qZiQGoUgyLOjM1QfD6Mnj+29n5WsxPBjpWaYHg0PiyLg1EQbSquxIsVnDio+7MvMgPr1PWYWaWaVARWc4Sz6Iu29CO4yhU+NZbLqRNa5b0otbb8gxJnqSizZLT1qimtqfX4UF1S1lSE1WYbu+VGgcu74uoG5nCM0nSkNcEY4P/RlY5Hd+zzaHZV+5Jbt7sXHUuH9doFa2nJg9VD8nW3Gwdqq09HWP2fdmP3O+Ugv5pUsRojvBLLpy93SonvoyiKui/+Z/RvLcD6DN/VhKTDoFCGfc0uK1VtHV4/fyD3mzlhPvr+gU6+v+ofPixba+8/fFLWqvCeoJqabzJ+/oBgYEqVVHkxz71YiY1Y4zNofAFzPjyv9QgjPpJ3IRKiXOg4hyFGkYciRHlRdhIcLmHmbHXyFbwHnhexAUuxmf9DAGdTlAHOb23GkII3z/IyX5DXgFQ0k07xiwLOZ8F4TU6+xJtc5RLgzfsPepci8Lpc54uAM3CTIK8Fo+SRiA3Am0qLrpFHwWMAxjYttgfLducLgJXMmHXvzFQJZs7EJdngCmBN6NAJKkpaBV7nHXkbjMsCPl2oLzAUAzXdZVUCAOvRCCnKKqwK6uqgVeD2/9O+JD0WuCE0gHyIZVyRL0kteAd/DJRuUIQjIv0CvM5XSPp+HayfXcSnwHH8vYzLb+OFTbAMoxuPlH71HbQ7Pa/X+g5hxrDseovaG1RikcOcTgGWW3QtqHXOKbksaFNZsOr3V2h6wbSceG2wliaVgAG9RRDv+ERNyGADsqpencJ5OSELmITCTi24LrzOq9NLEhZY9mm6D0gzkwKoUAurJEiZ0aQO0iRpAMt+koKzQDR+nFAsgwl1dBnJGsBx0hc2hwBSU4nFzSoHjOEukTtJlWwWqFMH6NI2GD4N0aYKIETaWREcgxluIlNQBhy0L9RogBZ1xOuIBc//aVeFkMhdgoFxobLBDs2BMfnAwAuBLk2tEzUqWSKU+lRMgmTkHemnVXtibY/WGIRUnQzA+Z5zXgyMq1QDBlOiRRw6MGKvgQm1gCkp0bVEVUvgkTvQLTcXFIRx4oC061F/ku+ZST8M+h7g07wBDCUmdIhzagBlGmlGsCxQ0xFS54x8B7Vk0gZw5MDAsrwr9S7x7lAtl28558UisOutVsFiBUZbYuDFa/LBKFEJytmANOkFWJ3TIVimRBMwIxRII7oxNcBwPDXlRAqMNUQUKcSKXDhRFTCmdEZth6XXbyiz9IFJvDpYYgMqALggWkOOMjWA9j4Yw20wGpM0Fip4fmFUKAfUBmKqFVrhrsyIksVKtP1DSkrtdsc9rsRpwziRygjalJxt7wQ9h5Y/GU2mXg2ok9dAKtWxShtUYpHCUUBOhG0whiGR55twLp1JSKirNPSQiAI/zcCIxaF7qj4FRItC06HtkhO1dT6HA8aqPqo3lBx1WUzVnIJ1uQUaJxepVEPSJ05xloEizRpZSSYtylsxsD+qp5JofQjG+AIMM8oFF/LZtB8AZkhNXVXQvT9jVs1UMdKHtp5iopTLdC2WXAfW1iw3LOJ53oDs60/jZM1+AFjfpDlrsy2qT+aa5YI7KiRJGLquwYnsLFmltwqeHnH+FdZ5gdo/1TH+Iyz4OjYOb8e2uTl3x7Z5Nm3OzjH+c9R17Pl6K4/z8X2ttS3259/mfCZeU3pJpwM/pUcuV7UHE1kPY0zWOpsqbIzJ6VDWWDNZWlJKzTZHjCh6HQvbxUixmZrDdt1k07rNRWH8XuVNvVA3qsO4cGJyOLTcRP20bz5UNavUUGs9v36mdXrPHt4uMGY42aDbGplNZEJdY8a+NZmYU/s9c0YtDSc0zelo0Oko7QzUPKHUAXDzZ9Z5Fe2+77ksTsIEZjz3SMTbYjaZEbk5PVajfpGPttRDdTc6jx8+zp67d79muMWZqFrm+pIFTH1Bbulk2NzpbDbrDU5zccyqX5Bpdr3+us8R/leT12dsTk3NblfU9Oxs09r08yiKunestQ8fPP9vL/dumDfarmp70evtD55Za3tPoyh6JvGu8dHnTz95eAvyzcMq01QpHmpeMLrU2CghZ76KiQbJRiunotppzXUOEoqEgjEfyW5ZVFgnnlNgeGUeOYpP1fX/fEmrczTOmlJP8f8rpfq2F0WfBE5PuWvtDXO09zSKHlzVJKXn1n6vFkUffh5Fv2atPd6LXr2cPZVg7/76rM70GMCM6KsMjcbislzD9RJ/JFrr2fnyyxJ6i/naDMOp1FaH4ZHRrg7Lotxhcep6N5kYFdMKlTzZLE/nPe9tOZOdq0lw3ipJmPLCC7sS5mjHVFw6NGbkJ0FV6l0XU9dbnFccqUIt8Vx/2+QiLFIu0peWpr95Bb16oMxccUTPrC0/je5JX07uwwfl++pCGl2qPxHb7b2w959Gz8v2/nNpNYP3KsnsKqZDOzp5E1Nv7vdFGzZzqvb9uUs1Y2IqGocSdfTQuVQuCOc1olMjYwoULxXa1Lsu00TUy4xdiq9R82KpRj65cz+JJXphl4KwaSYU+NM+nRpT71NvXg1qxhTIO5/HXik3YZHiV4ZL+HXFJo0nT+5bax9Fn0g81K7uRvesEy+jXZtGs8fW2vu3ZJHqcEfqJrPUaKLBlKi2NuYk8IrGoV835or0qGAOqSMIqZ4N1DHGbFOo0PZCza8ydWPMuB84dMk3xkzIwTTJHRtT7Mt4weHamGWSDI0pBv2lqVDJOCJ1Y3w6McYMx7kKin/GwS2lOvO0VV48e35Ve/B59FL+ooc6vmaYRc+fOfFhdM/+WvQPbsEi/WlF5MbMEtJIh+uJ9m+61BFcQzicUs0sg4X5yBQpNh9lQTA2QrgvcxL0tI3ZiKjS2JiFty/1L4Ev9UezI0NnxojabWCcKNOpOaO5lIbLHdd8lKusxmXV/2q+RO/AtLqkTOHXZtGl+ifZ8cJJmOX4Qfs8uqrdujsaH5bZHcXU1EE9I6cINcFEsKSeaLVNYzrUygbFNCSJwsLVT5elUOrsvC1UN0tFrywIaSkoKAyNJOTvOFGlrhn3KK5IXW7Up+sifshJGPGQH2bBjm6stkiOo0v1O056fC8b7kfRNfWJFHeFlsTvaVf71FIxRapK7NMNBE1JIkmMKdJ1MWbhjbPiXE9CXlvX1yYJeTcJ+1TXVOhMsAgkh5GyYOTaK3ENY5Zlj/oV8ahXidxmjjLjMtM9BLCu9pPciz6xTjzPBvs0emaV2I0u1SWjW3UzdtmAfA11CiUu5NmphFTsBsGySVPz0XsmntBCfTJteodTY0zNYUihhBW8LSTR1jOlgma4y5j61JXTHNOuJjQxOQn/0U15dx3/q9HX2a/OA9uj/T6LrjjK1j7Zy0A3uqY6/Fr09LG19t69sn2xJzYr/9otOk7LMEWiotqe114iMaEdQclIPSV2mNChU2oTaJsO1VS6JB2Ib+JgvERiLqjShRHyerrUNR/p8+iQhkYyGAa93ITfcJnppy3/9fK02q40tZ5Sanhe8+5e1L33g1E36mr5wWjv0TXVfs3QjS53PrrXjaI71m60RdGrT7p7e7ceK1Wmzx8wU3KLyuHTXBc6NE7EdCK4ydoYc0Qlh+U7+K5rPtoMTEwlIyHlz8Y0SeDTqTFm2BdU6BpS5fQUvf5QrbwUUwc5XDe3wCtFn6edYzZdWlJq+sbgd3J9Wqk+HI03f7Z+QFXX8umXlbqb1tVvVij7JzR4RaLUD2/uSG2zZ7mYYUxfZVqafFnONzBmuKDypBLTjtTWg7hU6NDuWhoJ8Ki7Sez3vZGROKV+ZzL3dgXFwOtM7MIVrHs0nZRiV0UZe0u6p6dld2xstVSo+FQ1xj86LNiYbG5BgOdraHNz8zrkKQHj8/PgWBi4HGJnag0cJ9WptXkNU52vHq7Ovr6+w8a5WGZdWpCIivnIDI88ot1DI2UFhXMi72hs5FSZ6pvDR2ZbLWM6HtGiNRHCphgTeUcj6WzCeOoRxcVERe5LPSIKqktTWJAT1boxGwRCZZpjFCnJMZ4RyNvhNQLXlyEbvznGmHpztDRGcli2h46BRNuM20JH5tzoTXXlgAmUVrczit6yXTdGtRm31xqHZXuscdDUZbjdFLU0ZlSQ/xXMulm4WOcYO7JJMZ+3uo09Urs5Qyf9G33LV9A29A5NzNZUJ1sJY0y2lc9GwHzg+9vVq+FcXzL2u5P99X/GmPb7+R3+Bz7ejrY8nGCWYehRO2/DWFTqMc1ZeKIjLpgPKp9Wkf37AciQIhuTL/1MlT/oPyIE7o4g/ZReQfqJ56L0HieOkYojcu5V8khS931aSJIwdF2DE9lZjqAZMfMtIBnHvNvsMQNLMUI/LoA3WdLKqnGlEvPtZmGYsAEzpIhH5Ke1LA7AmyyZ+guMK6OtSsyzfDCOlEzAwCVpVkqFOnhL/reoCN5cSez7I3AGesEHW14b5/oOCzAGOwGJ6IHfF7ToGh+weTEcGTAAY+2SezhsXGxwBtanxsyShOyips2ZMmgJja1eSBiokYmGHYI1TjKKOqdy4fVlwgQ+VRuaF1hvwLKDmsJqUlmNnooiqBOSXNRgPZK81klBrhSn4tSikYdRp6ABzQH1O6TrBotpHcxoVb+DUhwsOis04rLUfhvxHKzYTpMgbkGG01YY9CqpcBtXakHij8F4TeLCuOx6YROsn13Ep9A7yTC68f0rMafSY4INyGrkeVWlsDNNvIJ0eK4l084u+UCVllJ/oTPlQN0icmPXV0hjCjvndL5iRi2odc4pWQMDqgbxjk/kPLQ0qZTBSUKtPqdimMCnbV0uMCF/BQz73hgOyRI47tEIBdpAENNSzkGKtKgDMDJoUQlCoQKGSQFUqCUgC+CE4szonWQwoQ64tbnrMUFM+zpcz4AZJdpA0BUObTpC2l+AsaSq8lymU4jSLBMmK4eGF6qZbp06guBYiLhJZvROMgUqOxOvkrBBlS50UAiWjtG+oCkkUgqBLl0AG9CpQkgN6WAuc0wLKyII4EzjQsXu0NxBqURMmdE7CZKRd+RMvMo18WaYYEqnCowl1SQMVaEZNkgSYExzYOEdKyw8fYMfkxopBlOiRRzKVN8TVS2BR+4AzKu8HIxQoakGQ7HEWJ61JQIXjGqQXkjZgIRLKx2SrRwMn+YNYChTe0/UdITUOSP/gyvvCSOMicZgOVZBsmJmNKkrOAQzhlR12KZCh4oqVRpKqjKroJ9qxBcrMNqbTC/A6lxUUmRcycKY0+5YPQTPqQBgVfWGgnAFYE4TMKfJdNfVHOtPaS6JKg2+TGeK+IpcOFHdfGASr16JhQaNcwrmk+1StQI0Fl63OalSF+wQVCejDai3Eu3YBlQC64ZzjwojewTlZKtL09PRpGaBmGqFVri7+TBOpDIC46pAxupwQSJOwWjMPaJeASwY1YiC+QCCNZHRgEGNnKjJOBrlgIh628AwJPJ8E24+Tvej3xIaHDAD64v9FFJ7RVpsCANlcKsodDTDDrr/JeyP6imYodiu9kdjSB7LYprxqgNNp5J0MjtJYoqU4LjCmlluz6oCs+aIC3YkWDrEblfi1KZIANpSdIFA6jO4VFugY8WJWZESH/0AaC/skwwUlB4DoBiEiC2a0nQpAqKstwod8pTGsUfFzUwEcmn+4l+8/dOKhzrOR87EI+QAf2HNAFhjAPAHkk/+sfei6IH8TTqj6F3jbfpzADKkyMwHH1RwvhVStjx+9uz++xgx0KdKDNGvZcvdKLqbz6P08TCsanwu1aPX+r6bgbuPs+Dhi7J6YJ/vizHyZr3Bu00GzabfDPL5r6+3R5/oKN97FUXd61aHq9rLKHr54J9be//RURS9krLmdzEdKqWCWWaZqAoElhpMkYnZUCy+kNdblihKVe6/jGYvu1H0yNoo+p7/fy2M7o+jvZevouiOtfPTaut587lfqRUSBu9cTiDgVmT5KJRp4UUaD3tVi17dV3gUdV9Ye7wX3TBrFh5FHz62ZWc7a2+shkDkr1ll/K/LVWGACZMqLlJYxuvFXvRc5rFyfH4evVR5LA+RlaPorkMZm1BuDU0zeUedwoAG7MLvO92e44IlIy97TY2iJxJ3oui+4DjaUxAqG7ZnTlyqR8f225VS5fUpzXCqwwc0hUEzrlIsIO/4lT+Mui8EaTSz1kpd4oVCGq0jOb7iavXKlkK5pFxlkP60InJjQYBFmR8QAuLPVq4Mivzskyj6NcENs2YWlRUeRNGdJ1I8tlqPTx24pNxRs5rd2WFZFIxmRv1S+iJ+9lF0JHgRRXcE96KulZC2e2KVgIsOKFUVX81LfSLmk/GJ2hiqW+r/8WbLanlc6/6WOlPrvooeWmtfRg/K1t5/kFpbBm+PrSDE12ZLf2xnDcRiKBZcNBZ9AAO2Ld/4bltqOK613oo+f3TH3t1zVJ6/il79dq/2TDV94/X1/WpZgP2ftpVU4bx7Bf8MyBC+59UvK5TzxjXiFy53SgNidyWVly+khAQoNFnlWCS853VKmAuin/1stsZ7X+uiTpHm/BT5W1p++LAsqzy5q4wBoMecF2T3OCHLMv8zAkco3S+K5O48PYsnRGfuE4aGt1cR6t/zl0mW2RG/fs5UUYxyfXlkUmRNkPKKHOM/IpGdHAX/ndnDEKWrCGL644iQpD8dR2KuJJ/P57MB/WnUyfrU2d8cx8hdH16JeQ+ir7+Gj6NxbJI0B/ubvs12661PA3/ucHNGC3PuTCFJwvBdcA1OZGfJMKvayo43XeAlByrz5SWX9Bd3uKsF4jge8Q+CZiC3fMRxth2V2452PwvwZrvMle/44byc7o/zmFm+Xb56s/1Nny4ucsoHA3x7We1kBNezJpN7/b2xm5vrkv4qDXeb47rrH5uCLfHg72DkRPGyrMQK7F9nJPYE3mwSN5eEsbwE+Hay2X3C0M0EsJcbgON5Zst9LB9d3iwUz4BxSUiKwN8Ho0XXAKNxAc7peYOvsATfRhjzvChd7G+OaZ2d4HnhMn530+J268o9bfG4yWi0ffYW1G8AjQ2GYlMXmhxZsyehINuoBqqLCmtlFYkc7bEqicfthJlMcnRbT9uLR+J0Lr1QpSak1cC5qxnTZc2emKHaKAYaFxnWyyoSOdujMr0i4Ns15fHB0veTnAAX8SmGNQriuDqOz8CMbnwq9uT7wLhSCxJ/DMZrEm8fdxNvCZzuBr2d9cIVbqaz68XbwqBVW02qwWLeyN0erekQnG3p5Bl8f7wGPtXlLxlViD3BKliAkQZUhfKF+2pBrXNOyRoYULdKbpxiQsm8vOsKME6o1tmlDcDo0LQ/3XEpdMjZfrwuA8TZlb3+As/gzJG4FzuxQxWw/FW4kEgLPi2BJtWoAUxoApgUQIVawICC3S8IgEE/2AeOYxL4dAGkMdXhsFgDaZVG4FxtJ9PS6nY728v1zmjbxbXESQqvlSqwlN6y3CPmQZsKwJTWYIioU0dAdVmtI/Y0Ile4+HCiTV1BSficUgucy01ZlJ6y842NQKq1lTja84Uh2PHotngH7ZZPuwYZWNIUq37tmI6ApCemcaGywQ7NBbvS27QuNcUvSAVtiq0TO1QTNOVeY3MyGONpxZluq7QdHegMC/b1nzR0tPPJmoK7udPwbOO1uEXX0HPAcBOMqIVqsNqXDtxTokUcylQl5lSUfkHfYUJKxIILDbnZ1HKm2ynlnp6y/c1xZD0sSMEVlvvwxxbwV8GNleN/W4PcjJRp2KE1WjRylgCf5g1gqP8akjs0kggcCrQB5JC+TlpOR0FMt1nu8PGip+x43UXWQ2rfX/Bp70vdzR14Hd5ZxseQehkWGE2a7IbAkrq+l/IqeEdWYLT1VGgCZgzIoUg1yJ/nnYmc7fqB2+3sDh/P8eRfAZ4LCz9d7omfE6spzVXc4BhgDMiXBhx6cVIDr8gFgKqesReuAJSkzXbpJLtZjnYt1m2WVfY3x7bbOZk82v1FIuvhr86b4bU9J7StisdiA9udLigxKj5Vm4WUEXs0drCetLuYaoVWuKtDWqyeFuZBIqgHXrc5KsVt5HwcHNx+yMTZ1z09uLE2583K5TbSgyO/GW9DQa97CbDCcpeIjoEz6oEZXxCiocMwJPJ8E+oQq/pEu6Pr4gq/oU9OnA/zFKRZbLeu+YXThudIB+7wXw9PLRrTL8ViZbvVRX0FhhY/GFOcLlNMAShCqnXdQON3XBxdEp0X1BMDsHBVYIrLWtXtAGbV4gcpTtJrWiFVUeMHZBb+QUEAs1dYM2ddi/eqmM1FgiKAN8Z4kRDtrcIpuEde+gQfT4z29XdJ5+3Ju6y8DPGW5cF5NsFb4XA5O7yfRNmpyhTPou2KXWxWkPxPKiWEDoP7SaUAQAAVOR+U5KQ1C+FpnrbjJqLMVFU9cTPzmA+fuP7yQ7uXnc9fSOx+cvR6+738ISfqmemH/l9dkQRwx9QV/898GEVPy9aWv9hXFH34NHqaL+Q6uh4SAU5T1bMI9ZqkfbgX7Vp7TY2Onlh751W+kHMuvjgJACvU9dQAcP5ydE+I3LNOBPnDIo2yi023G058n3oNYTUhHkTPbTmKbpjzikXuYjfo6rp49JWaF4r8pH5wFgAOjqkqGkdlfSKkUrAuJr2l1oUiy/pFAHCGGtvd1Na81vOBKOQVJV2vHVrLrFA/FMun6G8pVV7ubNkHnhfx9v31pdrMizOq+v8Z69WvxKKntqcoVb/ba0o2wkxU4e3Qz75GWXPxQogv/XmheN+nKQAQkmcE7lRFA/TzWoXEDw6rwmDG3q4KLF8yuWytjHkz3L2K3V27Or5srYx5M6KxH4Dq8AFNocm7xr1IiRuL0NH4sCwORp4QbX4Wp0PkVzSzuc1EAUsNpl5ZuEwfVrUI5ayqFhAogvTrvsIBTdN+k92O8/P52+S1br6P8ccYiEqmOnWcpuso7U3MUdGbQ6VUMCsikSNwdeF4qxFp+tLbZKb1T02rrW/dr9SKiMShK6yeqnR9aqk8rm+shlrru6m/FpCEoUErBGRNUbqWln5K78pZlae0bq7NC0gCYrHgom7qIT/84WlLK3pCKVVen9JaQOJNKRYKBZ3E1XplS+EO/6oCEr+EZ4LinDlBaXPzOlrr8akDs0+TbzUrIDmqWJgT/f/r29xsaq0PKFUVkJu9sGAzYIOzB4h+f/SKmCQoHF8wm75tOkpb2jpHr6vpG6+v71fLQvI9rxC/mlQZnqG/gvG7KZxhM7sSx/FIKeXaZ19r2tTfzFnj+/j8gf7a2tq81tkPzT2ms7+T/iYp5dx/yUKqrObxuVhaa62zIAwAgFjBaBTX4Gzthl9kkKWSaruFfTP3+3ur7Ah/ByMniuvvELECTSplT4fq2aLYbmHf5HwFFu9c7qv4+3g/wqgbcJ6Em4xG22dV6jcgo0+RVQeFDG/QFDnOZKt1ZV2unZ2VYNV/Q8CscclrcC69UKWmgi5FPjhQHSCjeYOmGgnLjLZaV51KVlaS6gmdAmDVhfMbMDNK9AYKjPoNEi9+k1Rqv+vO2+L1OgMZFOKKUlVOWzcl6FVSZo3tNOn7Uhf6inxZGt1e37/AxTRJakPHP5PVYIMw2C2tGJWE3Dg+BSbnSRDuXBFw3mPmU10BIy+YdmIKB2BcBJTEYX8lgRFVUxlOYwo753S+UkDTC6bXSLw2GD2319vpUb9N8c6Cktcks1XozssJdYCaK7MBBdN5SMO8Br2REztUAUsgXQRFAGUqA4PEKwAwkCh68bEyoSUU0aEKFNskaQDLfpICPfJXQJeoC6x8Os1sVUsBk3gp0JIWsHAHANbgvMdmXitVOaUdMGMQBAMUaC7lISwY9sOBug5hsnJoeKFCmypwokttwQUYQwpSMLZpg6ysGHMaSgiHJBkDDM53bNZu+bRrILMBNaUMtkb76NC2qBoLRgtXNx3TwooIAoUuTa0TNSoJjsEM+YvP7VM5SytLJxoKlHSLQD5ksxaVFeZUlCjTCaZUlKomWJBX1DAmNVKZKSnRdQgkcYoVsrLSIUkUe0T+Oh+yWYNchTKNJKa0Lxw0VJu0cJ5kDMXqMJfGViPS8zKR2SozjsWqUPWSMTjvwZB6CiU6lExCSlUHaaGOM/LVp1XQT5UTDaptCbJINuitsoIPhA5G1Mlz4MRqSnOFMfVSABc0FQ67KQDIrM7pUH0q01mG2dLrN7Kf6a0ycUpWchFhqJzXYLGB7U4XlBgZRoXCw6YN+mswShRORq0wlcdpTeLVwbKvS9PT0aRmVdtDSkrtdsc9RhZksMpAnYLS6AJht922u1TMa0BEFPS6BpqzV9u7RMHcSI24K2mtlHNeJ+QeK49BOSCi3rYCox0SUeCnnAUprKhIPZGoi+viEZF5UCUWF2cMQhMsSbDksiyuoPSC9ag4ALNGDKwKr/ZHY4B1to2Ti1TYKcpAJy0rSWI5aoBxfHKxFhk7OjhgTcgSsgugKGg6hEaMdcIQehlsIdkpylgnPSv97mQp7oaFYyZD93kvPes9evxgBqwy9bqcjhz62tWjkSefz+eFJZ7nDRoNoq8/HCFJIUnC0HUNTmRnEREjMdosSjc7xn+O/hjPiFFMQYzSlUKURLKAfOecvBZemwV46++cw5z34K1xLsvIwxiMnDjZQn0GON/B68MG+wERuVsHYzwE5zl4NVjggJHOpU/sZc7m3o8HGpsMubPWjOHPwZzf4JVhggNGl9pgBrK496PWhjPkzjozpMEcAOc1KDEFWrXVpBos5g0wY+QvPHd6ArSqaSkOFp2V1Geajlh5rb/fZHuXkjjugvMZvANs0aFpf7rjUghnIq/aqXqHQIdqybSzSz6YsQG5ZZ+SsfZ+k90wD8IHwxqLNZBWaQRMaQjgkgwEyRI47gmb16FaCjSppr/f5D7lPxbGupItSmDGKbUAn5oAQ7LpCps2HQFdqsOJkLT3m3SQiuQ3MA5bNKV90gbAfp/mzRVYsTnglEIgpK51okdFzf0mFfIe1w/02OJChbGuEfUu4KDcZDJJgAUp0dbcbzJfQtRjiqIGBor+gppwaEsELuDSCkqUaZRXYSZiFfFDI+gJDoXNkKpAVTITUpr7Taqr83RAil2JcAVgThOgQFX5ibX3m1zSudgs7wWvLqpUHkMP5vPCqFKliiCoTkaWeitmHFF8ONqe17T3m+RVQjvtNjjPBaNIRORlotInoqC8YodRjSiYD8QuV5UFESVnYM39JhmjgCjMe3HAuisFpDEt2WFVHI2VHRVxXEwBlh3HozrAuvtNSpccjsH5r9W6q66kGsgO8u4OJCQFVhwBKH766104b/cX1iz6gAJzBh9tr1JV8nqfA6BhMxp//o/vPvuXhSdqsitCP3UijuMjZ3yCD5eMSiQJteZQWzZrKi2Zyuwq29fqinP1JhkJAdBZQ2cDHUVn31hqrP3lxrJabVs/b+tXkEPq2W6CGg675yKBcXU0rmzbOG8bl/O3jetw27id/Fz9ajfBDdcVEthPvpa9gpR9QgJbKlQ+EX5n7GP3GUe1PJ3KJ4HYU4k5G65ZoN2Rr+lPG5CEjrSgs9XMWLvCasyLdsHbcPEYOkoY63BcHQqnT8bzouRnKzFXw6UQYx9bAutdcEPD15P+NJeAikvY2IcKrCvhOGG4i2cR/Fz60wbIdUUl9dcafclLaPUcOfrYShxz8pD+OiouUTUF1pVxHCnbvd7oRUQl5uGkuRDXBRXXtfyJrimEFqlc6OzifYiMCZ6mxEUEB+dGkEtExene+mu5hOc/J5AWKdzc2UUURR+AMe9C67se8AB57LHHygc84AHbxSVLHAvyy8gBKxA6e4499tjnLYG1joXZ8wCoescHPOABlxA0vceTyg6hR5g+HqncEZhcogQy+HtgcP89e/YsHZtTRKar9YiRy0+4JG7LMNdSdxbrerG3/pJSC67579t828OMZTXBs0iyz6l7M1/L+2FMsdVqFcIw7LVarW4YJii90dHRWkLEQRKlJCmMjo4GhEoXOfSSJKmPjo4WEpAeoVCkqSRBu90uJVC5TrGTxSQ3SS9drT8cyXAtdYdxyf9pIpknjGU83iWMPgpQSq3nB/F2IJ4bxNeFKPiACUIiBSTRC8Naq9WqEyoBVAnrxIFFKHQJpSBMlQJFOZEtFFnoJWHukV4aRm8BSviHT3MtMxzuJ9MZ02+vGdM8phdeUHct1F2LzaX3T9QY1+SBx9RDTvE+USKKEzJKuQoYbwY3hfIFadXcb0c8D61uCNJFCsUwTCHRRnsqUViEEKpUhYCqTDcvEXqoLLZQar0chDTzNMfqaa5VpkPX53oxX3fx2+uuxeZS18tUWRUNryEOPZR6YDSe/UCk+yMYwMS48l6y5rpuHTz7fjsKotXqhd8OEgatFqTVoqhAr7DUaiGwCjGiKFMDXBDQIenKFkwbqeQSCeuhZaN/RUEczGyGh81T7ZsaEp2Jh6BhruUFGin4PWTMXsZ7mvZHeKpha8a3KeOcGsd+IDL3ls2Cu7kD1hYmihOqPC4UBmPeDKqGiK77biCen1bguu478Xsunim6vwfiYuquuwtE4tJVfs8FYBeoELgUZXpcAKGMUgpqEpTQ/b0cIm7dtWwED56nOVZPd2wyGa4Xh01TvSGJJACtW9IrZ+C19ZdQ5dbft8c+tl6VxaFuciHFMdwHJOGQrSXWS2QZgK4+cxtZOMG7Kv/glBDezIcRJVLKonkPTF3eCwFSalEU8P7u1QpdN0B7KhEqReRQJ/y6qVTrQDlVukA5RYryXlg9lwgizTzNcbpTJsMsU34oBTlfyJ0gSqPSUPqY3t76H4KXYYxlrc2+jetnmUrJGlzszbsFAELxgY1hHqDPXEbvBqIYZRCC8YsZm+ffeG7cr/iOlrNUGTG+Ehp4NIabioi6MaYk7yUDcyKKCZHCTsyJIK6DJMyJpkfROtEUkUPdQL8CUIXWhEqN0AuklKHBD3AvmRhgVyolhqJehArGnJgLxJRMOlLNplv58WfYdpnLyrQvNCrZNqfTaeuUM0YbYRr/Qc0FlUg5dJThsX3qdkArN5tJmQyKfYQx5poCkMFEUaQPjUU2C2AtE9m50MWiv77xtUTq8RxFT9K8ZlklLJ1JFqh5g7GPw/OMI6XzLphbIl4YWTQwBXkvWTLvBQpxVNwZ/9rfS7oGq7gOoWXwUYRVoGmAVWr4UIDKNSkdpAIoAb22lDXolGCAS70XmjvnAEFYFSIOnspEBpO2bx4ddW1MH3PMMWnnptFR61ZU8qc/SZJpxD7FOjWXQ0cp9uFSqfZ8IoIgmEC2ftYHwfWM2rodw9ZRxkTMNgLQMJUxStTXN5GnJaqHltJ8/jeBDtXr6q0/8jOZE5adM+04qs7kiEGUq4FKIfTQUJCXRhY/hA/goYgXgUIoHyPbITYowYMHJcAuLlZpy8c8BoGCDGRgjEkKWCVIpVxEBgWD0kMCPYPTRQaJgV8FoV6QUiYmBwgizVR+JoNJe+NHQ5xpmPQTlbR7NpzeDB2RPtAYkmU5DG1TUWs2FAoHNS2MwiHXZFPZ88mauTCVbOMsf1meiey8xg1dAE3QO4mJbDgSAuir+JIqTUGASuUnHRXyed5aqeRJFyvB9YxN6QCcCP3qd6JHHDoXb5PhXb6xM9n5x4+ttde7zNwMXPcbv6UzyQCOU+t1HeeySMd8CCglKREPBTFFKaXTDYKCBK9DsMq7IOUpUhaCtpSOPAWBXHryFORSI1SKwC9ABu1uMajJU6STGOK4c4rFwJgEe3brpR6WqmGnEJsE5qHZPwirQu/HLW+JQSW9t7pWEpZeKRAcDSAJl/prOS/hlCT7lgiQI1wQydXNOGtzVtN2AIt2A0qGtmftH/rpr8tH4ZlldCpAXxMEwFt/BUgmAxX7yAYIxmPeTQAHYP6NEEhk1tYmCF3dHdb+nMNP2k+t/f7Z7Iet/f6PJTU9l2f74R9yHluAknpj9OzV+Yd2r+agXB7HaYf4waJEXgpZjD4I4ofVcyQRpx4BlShpS5h2XUpZwjamQKqAv/0i8sii2ECTGrCoRQ+NepIS511AUlEoUYIoByBKorSsbtksn8BIwbhuX7xUf8nXpaiYWkJQDsRPRa2W4VCwGliP2vCMMmQqxYWcpZ39nHXihx/9zMx1jsYwOMSYewqAawuLNfN66MLCoSQMYhXcoQzsFmgnnbJfnznYtypX5/qN2Z4tv7HrbLZn7Z+eudrTEbMr5/2HP/3zM3erKXkBLu3gQ0C7n5kBD9uLKHkXuqDiBIaiYrq40u4ZrJhEIEVAwUQAmLAAoSi7BSAXoSRdolZ0I5CClE4Y5QBBpJHrXe8D6EYlf0pgpBDX7Vsv/Ulybm4MvrIxNHu2c7LUsFmWv53L5RomV6vNhjBmLBsg/rjzo7SrP/TmXWazv0c1JrIO6KNFV2HtAI5hXG9uUxzV0m6BxWzKZfMYY79o7Zu7Ct7Zt5kTn9pfmM2ExU8ruDM5/uFf+fTvzdytopO4/U5KjYb3LrjRwAO5YMbzvChCh8kjYaIoCuslN4qiR5LBDaGJiJAubhi6UYSlohTKoaGKvAn1euJGQMGEpR7164nC0ESPzAGCsOpDBJWgIwmMFITd/nipJLk2yST/QKXeBDnCeTd4N070JvoTNM3anB1SsOdTNw/cu3dvNvvWW1s+ttb+VbHzWUQGkubSGHB9OJd5JsM1/kT4IltLHV4szkyeW/nM2seCtyoilbb2h69vceJdd/YXZNzZ18tWiZs73QJ8No0BCnrQsV+Dizxvhh4PZSZVoIkVO2synlUPL6UT1s4F4oVeOlbohaCEzkYCIwWW5EYktUjfdkzRHVuw3JIqFU3THFMpUfNyHjz7mT1r3zHNpgDUKYLp+GghpmtgLuuA1jw0BVkgET7E2MZBgJYYft6q8cOa2c//iIi/+ukf+vNbyzUAo8ZnsLExGAzO+gRww695uX0Q1nMBeiEoo9JEEt8hy+YRsSWXy5laCF9CNQx/6pxCxTyK2uzLFKp84+Dg6q3SeNZbFfvx7L8CWEZJJ54HcF5MrZBsT1YYG4SNm0FoZ2wqdLQy9nUt37D2p78txY9oVs+c2MLVeEWUe7QTROOz+Aw2Pg1cAQ1j4FFy9SCs+hDJoaPobCUsLPcrWfZszDHGmlWr/8i5N1U348wtqI2OqZRyKOUfWvvTDu7sXzt8C2A6EUjEn9S8os7jDuMesgNgGOZGtSeyb+pwZx/bg9ks05UxrqvZbEtpY+Y+D1BAA1gV7S53zyAcpCP1cWASGXxwIbs35XDK1aprc87aPFvzJWJDYaSWSrZhRcHfuQ6tkdo/aT/+xdls9s2P7Q/PZhWonIf7oMC5PDKQXMyo015JOJOxeZAE7ybGzgPqfT+s589JNQh+4Rf0JxTc2S9I47RbTLud+HOo4ApoOH2Q6+ddsKpDPGNhn0tULr2U5azDkbhqdXYouFCrViPcNNSW/cJ2QAsh/4ZQSNO+VipdqylN3OTpprJDiTdmtbb82WefWeukAzP7SBJaAokbdgtA32IeeYA+clCRB5hKf1JDKxPZBoBwaHjwU2v/sIaf+dR+fLPpF/6QtY8z8Fic89pirgkEVhq74SJ4mOTqQVj0ITat5l419rGbwLwq9wLqq5pW9SdYWppvvVqePWdE0zQluL6jZCxja7sUyLBDX/TH/7g7+/YPWRG/IP2iM6cCzobzmBiFtEudeWXPhS8Sw9BHWrKUdgNAyzc/s39KwWnQ/0Y6Dfbxf525ma8f2Go+hCga+P4XQVTAIrRqTp+G20hHCm2K2oyliU02axqdph/i2IqPg5fjZE2ttuZDllVKrDau7LZfDf8jOfPOI0Q7DP73t//JN39mNnOlptw6L9/OqI2dRXWlfZ6zK+kH1Q3eltrnLVs8ExayiuTyb37k2381mLmZr8Xacvq+738pPq6AhoON3D+IlEnxpFXNLk90slSWLzfWAelECYe6UXDgUMYYNdaN+buu3JTpPvDeEMiz8Uf1LFYHXVe+TFDjktUhe+vJ5/NfxuqCT1Tgqji5PCYtp90bWnb5/hVjHQ7UqJAp6smAQw+li+aCv/dytaooigm9rdV1f/RWpN9fxRXQ8GdzHBCERR/yGSub6H2ChKp71VW1G26ozZw58/mkUM9Vk3KLxi3IbW5DVhZ8uAgnp8c3fjpSqKFkLEtsrqKCO3ADvWTmQNRUVBFOuOT7ZAMPBGExxHMWdsP+EHJ4wbOEvwinxdsQFdAAVl3gAaw3INA/BkYmazjnE7XoIqQWYYVo6K/m/vEj36IP0eB3TljLfIhl9BpVhBWugAaQfs6fPMLKD5/ySvCL8Ts3Pn9EM+SdElCgEA1wVQ6IjrRFH9Cw4I8kwyHRQheBBRrIRVwQgDUh0LC6gBiOYE6mtQgxrRfp4VJOxqHVhBhtES8EYdEHNPRXESdnOhaWCTBL4VZ+BMam4ZIgLAY05PP+iJ1Ccoz/iCn2dSaz5bCP04DF35s92evjgdv4w87kZBasTE5Odv6Q68j7051OZzLrpdPpTPt5LkND+qv+62Syd18n62Xf3jP81T6xhNNY8H2/gTIYgP6YyW7BbT0RjIcC+3Vt+L6/wHEswtOxQK93uzdwd8ye5+Euf7NAHgk6dx4bGww2djcOzs35aIpmFnkM2gRfw9rYoBTYq72Nr/tI1EIbNhqNubk/g1POIf1ZYgLLxwE7p7b5XHCB53m/BgY4pc9zGXAWTGA5C3wIg90HtoydBQYwBfPcBm0ySpbTwacwkPFsuFv4MRDYMjidHEbJeZ6DVogKpXf7swb22y088e0aDMgadeAf0p/AQu3e/nS7797+9NPRMlg7SA6UKb+R76+CQunefsP2A1tAjRjQlIPIXEnda/huW06DkoMH5ywNfAa90LoNzwJdhh+Ey8BD0gZ+Q5MdAoANyN5Us0bQt9CH78jigZhyDZkq1G7DYWz7oIDxQRYWVlMMfEOGSj6rdBtOaQE1Phr0h6LTLbQKpdvwrJBVnD6llmqwAA==)
    - **Step 2.3:** Enter `wget <paste>` into the terminal, replacing `<paste>` with the URL you just copied.

wget https://softwarecenter.qualcomm.com/api/download/software/sdks/Qualcomm_AI_Runtime_Community/All/2.34.0.250424/v2.34.0.250424.zip
            Copy to clipboard
    - **Step 2.4:** Extract the zip file by running:

unzip v*.*.*.*.zip
            Copy to clipboard
- **Step 3:** Setup your QNN development environment

    The steps below explain how to setup your system and terminal environment to work with the QNN tools.

    - **Step 3.1:** Enter the newly created `qairt`’s `bin` directory.

cd qairt/*/bin
            Copy to clipboard
    - **Step 3.2:** Create an alias for creating environment variables

        In this guide we’ll be using environment variables often. We’re going to create the alias `setenvvar` to facilitate setting and saving them. New environment variables will be saved/loaded from the new `~/.qnn_vars` file.

echo "alias setenvvar='function _setenvvar(){ VAR_NAME=\"\$1\"; VAR_VALUE=\"\$2\"; FILE=\"\$HOME/.qnn_vars\"; touch \"\$FILE\"; grep -q \"^export \$VAR_NAME=\" \"\$FILE\" && sed -i \"s|^export \$VAR_NAME=.*|export \$VAR_NAME=\\\"\$VAR_VALUE\\\"|\" \"\$FILE\" || echo \"export \$VAR_NAME=\\\"\$VAR_VALUE\\\"\" >> \"\$FILE\"; export \$VAR_NAME=\"\$VAR_VALUE\"; echo \"\$VAR_NAME set to \$VAR_VALUE\"; }; _setenvvar'" >> ~/.bashrc && echo "source \$HOME/.qnn_vars"  >> ~/.bashrc
            Copy to clipboard
    - **Step 3.3:** Grab the appropriate “target” for your target architecture / platform

        | Target | Architecture | OS/Platform | Toolchain |
        | --- | --- | --- | --- |
        | `x86_64-linux-clang` | x86\_64 (64-bit) | Linux | Clang |
        | `aarch64-android` | ARM64 | Android | Android NDK toolchain |
        | `aarch64-qnx` | ARM64 | QNX | QNX SDK toolchain |
        | `aarch64-oe-linux-gcc11.2` | ARM64 | OpenEmbedded Linux | GCC 11.2 |
        | `aarch64-oe-linux-gcc9.3` | ARM64 | OpenEmbedded Linux | GCC 9.3 |
        | `aarch64-oe-linux-gcc8.2` | ARM64 | OpenEmbedded Linux | GCC 8.2 |
        | `aarch64-ubuntu-gcc9.4` | ARM64 | Ubuntu Linux | GCC 9.4 |
        | `aarch64-ubuntu-gcc7.5` | ARM64 | Ubuntu Linux | GCC 7.5 |
    - **Step 3.4:** Save the target to an environment variable

        Ensure you’re using the value you obtained from the above step here.

setenvvar QNN_TARGET_ARCH_AND_OS "x86_64-linux-clang"
            Copy to clipboard
    - **Step 3.5:** Add `envsetup.sh` to your local `.bashrc` file and reload it.

echo "source $(pwd)/envsetup.sh" >> ~/.bashrc
            source ~/.bashrc
            Copy to clipboard

        You should see something like:

[INFO] QAIRT_SDK_ROOT=/home/qnn/qairt/2.36.0.250627
            [WARN] QNN_SDK_ROOT/SNPE_ROOT set to QAIRT_SDK_ROOT for backwards compatibility and will be deprecated in a future release.
            [INFO] QAIRT SDK environment setup complete
            Copy to clipboard
    - **Step 3.6:** Install the remaining dependencies via `check-linux-dependency.sh`.

Warning

This script will prompt you press enter 2-3 times to confirm additional downloads.

sudo ${QNN_SDK_ROOT}/bin/check-linux-dependency.sh
            Copy to clipboard
    - **Step 3.7:** (If you are cross-compiling to a Linux or Ubuntu device) Set one of the following cross-compiler environment variables based on your target device.

        1. Based on your target device’s OS, architecture, and GCC version pick one of the following environment variables to set:

Warning

If none of these apply, you can likely skip this section. This is specifically to set a cross compiler for specific target devices to help build the sample-app executable.

            | OS | Architecture | GCC Version | Variable Name |
            | --- | --- | --- | --- |
            | OE Linux | ARM64 | 11.2 | `LINUX_OE_AARCH64_GCC_112` |
            | OE Linux | ARM64 | 9.3 | `LINUX_OE_AARCH64_GCC_93` |
            | OE Linux | ARM64 | 8.2 | `LINUX_OE_AARCH64_GCC_82` |
            | Ubuntu Linux | ARM64 | 7.5 | `UBUNTU_AARCH64_GCC_75` |
            | Ubuntu Linux | ARM64 | 9.4 | `UBUNTU_AARCH64_GCC_94` |
        2. Download the corresponding cross-compiler from ARM (or use a Qualcomm provided one if you have received one).

            1. Go to this page: [https://developer.arm.com/downloads/-/gnu-a](https://developer.arm.com/downloads/-/gnu-a)
            2. Search for the GCC version from the above table (ex. Ctrl + F, then search for “8.2”)
            3. Find the latest download with that version number.
            4. Scan the download section for the proper compiler for your host machine and target device.

                1. There will be multiple sections for each type of host machine and each supported OS for your target device.
                2. If you cannot find a cross-compiler for your target device, you may want to ask for help in the [Qualcomm Developer Discord](https://discord.com/invite/qualcommdevelopernetwork) to identify the proper cross-compiler for the host machine and target device you are working with.
        3. Set the environment variable for your cross-compiler by running the following command with your chosen variable name:

setenvvar YOUR_ENV_VARIABLE_NAME_FROM_ABOVE "/path/to/installed/cross/compiler"
                Copy to clipboard

## Part 1: Select Your Backend’s Op Package

All models have a series of operations (like `Add` or `Conv2D`) which transform input data to perform an inference. These operations need an operation package (or “op package” for short) to tell the specific processor (ex. CPU or GPU) how to execute the math. The QNN SDK provides op packages for the following backends across various target devices.

Note

For details on which framework operations are supported on which backends, see [this page](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/SupportedOps.html).

Optionally, if you would like to define your own custom op package, you can learn how to do so [here](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/op_packages.html). You will need to pass any custom op packages into the sample app in addition to the default op packages for your backend. Defining your own ops is highly involved and is device dependent.

Choose the target backend you want to use for executing inferences with your model and follow all steps within, your options are:

- CPU
- GPU
- HTP
- DSP
- **Option 1:** CPU Backend

    - **Step 1:** Enter the `OpPackage/CPU` directory

cd ${QNN_SDK_ROOT}/examples/QNN/OpPackage/CPU
            Copy to clipboard
    - **Step 2:** Build for target

        - **Sub-Option 1:** Linux target

            - **Step 2.1:** Build the package.

make cpu_x86
                    Copy to clipboard

                This will produce an Op Package library which can be checked via the `file` command:

file ${QNN_SDK_ROOT}/examples/QNN/OpPackage/CPU/libs/x86_64-linux-clang/libQnnCpuOpPackageExample.so
                    Copy to clipboard

                You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/QNN/OpPackage/CPU/libs/x86_64-linux-clang/libQnnCpuOpPackageExample.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=53ed9d4cdc432d86511fcce06148c0048802a0c9, not stripped
                    Copy to clipboard
            - **Step 2.2:** Save the Op Package path to `QNN_OP_PACKAGE` for later

setenvvar QNN_OP_PACKAGE "${QNN_SDK_ROOT}/examples/QNN/OpPackage/CPU/libs/x86_64-linux-clang/libQnnCpuOpPackageExample.so"
                    Copy to clipboard
        - **Sub-Option 2:** Android target

            - **Step 1:** The Android NDK Toolchain is required for this section. If you have not installed it already, do so by running these commands:

# Download the Android NDK
                    wget https://dl.google.com/android/repository/android-ndk-r26c-linux.zip
                    # Unzip the NDK.
                    unzip android-ndk-r26c-linux.zip
                    # Add ANDROID_NDK_ROOT to your exports.
                    echo "export ANDROID_NDK_ROOT='$(pwd)/android-ndk-r26c'" >> ~/.bashrc
                    # Add ANDROID_NDK_ROOT to your PATH.
                    echo 'export PATH="${ANDROID_NDK_ROOT}:${PATH}"' >> ~/.bashrc
                    # Reload ~/.bashrc.
                    source ~/.bashrc
                    # Verify your environment variables.
                    ${QNN_SDK_ROOT}/bin/envcheck -n
                    Copy to clipboard
            - **Step 2.1:** Build the package

make cpu_android
                    Copy to clipboard

                This will produce an Op Package library which can be checked via the `file` command:

file ${QNN_SDK_ROOT}/examples/QNN/OpPackage/CPU/libs/aarch64-android/libQnnCpuOpPackageExample.so
                    Copy to clipboard

                You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/QNN/OpPackage/CPU/libs/aarch64-android/libQnnCpuOpPackageExample.so: ELF 64-bit LSB shared object, ARM aarch64, version 1 (SYSV), dynamically linked, BuildID[sha1]=23c94257457f9881b2ce553ddf831ee1f7d8267f, stripped
                    Copy to clipboard
            - **Step 2.2:** Save the Op Package path to `QNN_OP_PACKAGE` for later

setenvvar QNN_OP_PACKAGE "${QNN_SDK_ROOT}/examples/QNN/OpPackage/CPU/libs/aarch64-android/libQnnCpuOpPackageExample.so"
                    Copy to clipboard
- **Option 2:** GPU Backend

    - **Step 1:** The Android NDK Toolchain is required for this section. If you have not installed it already, do so by running these commands:

> 
> 
> # Download the Android NDK
>             wget https://dl.google.com/android/repository/android-ndk-r26c-linux.zip
>             # Unzip the NDK.
>             unzip android-ndk-r26c-linux.zip
>             # Add ANDROID_NDK_ROOT to your exports.
>             echo "export ANDROID_NDK_ROOT='$(pwd)/android-ndk-r26c'" >> ~/.bashrc
>             # Add ANDROID_NDK_ROOT to your PATH.
>             echo 'export PATH="${ANDROID_NDK_ROOT}:${PATH}"' >> ~/.bashrc
>             # Reload ~/.bashrc.
>             source ~/.bashrc
>             # Verify your environment variables.
>             ${QNN_SDK_ROOT}/bin/envcheck -n
>             Copy to clipboard
    - **Step 2:** Enter the `OpPackage/GPU` directory

cd ${QNN_SDK_ROOT}/examples/QNN/OpPackage/GPU
            Copy to clipboard
    - **Step 3:** Build the package

make
            Copy to clipboard

        This will produce an Op Package library which can be checked via the `file` command:

file ${QNN_SDK_ROOT}/examples/QNN/OpPackage/GPU/libs/aarch64-android/libQnnGpuOpPackageExample.so
            Copy to clipboard

        You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/QNN/OpPackage/GPU/libs/aarch64-android/libQnnGpuOpPackageExample.so: ELF 64-bit LSB shared object, ARM aarch64, version 1 (SYSV), dynamically linked, BuildID[sha1]=ef778a6032b9356996897e88fa8809e742c81638, stripped
            Copy to clipboard
    - **Step 4:** Save the Op Package path to `QNN_OP_PACKAGE` for later

setenvvar QNN_OP_PACKAGE "${QNN_SDK_ROOT}/examples/QNN/OpPackage/GPU/libs/aarch64-android/libQnnGpuOpPackageExample.so"
            Copy to clipboard
- **Option 3:** HTP Backend

    Choose one of the below sections based on your target device’s architecture (HTP Emulation (x86\_64), HTP Hexagon V##, or HTP ARM) and follow the instructions within. The options are:

    - HTP Emulation (x86\_64)
    - HTP Hexagon V##
    - HTP ARM
    - **Sub-Option 1:** HTP Emulation (x86\_64)

        - **Step 1:** Set HTP related environment variables

            - `X86_CXX`

setenvvar X86_CXX "/usr/bin/clang++"
                    Copy to clipboard
            - `QNN_INCLUDE`

setenvvar QNN_INCLUDE "${QNN_SDK_ROOT}/include/QNN"
                    Copy to clipboard
            - `HEXAGON_SDK_ROOT`

Warning

Ensure you’re editing `<path-to-hexagon-sdk>` and replacing it with the path to the root of your local [Hexagon SDK](https://www.qualcomm.com/developer/software/hexagon-npu-sdk#hexagon).

setenvvar HEXAGON_SDK_ROOT "<path-to-hexagon-sdk>"
                    Copy to clipboard
        - **Step 2:** Enter the `OpPackage/HTP` directory

cd ${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP
                Copy to clipboard
        - **Step 3:** Build the package

make htp_x86
                Copy to clipboard

            This will produce an Op Package library which can be checked via the `file` command:

file ${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP/build/x86_64-linux-clang/libQnnHtpOpPackageExample.so
                Copy to clipboard
        - **Step 4:** Save the Op Package path to `QNN_OP_PACKAGE` for later

setenvvar QNN_OP_PACKAGE "${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP/build/x86_64-linux-clang/libQnnHtpOpPackageExample.so"
                Copy to clipboard
    - **Sub-Option 2:** HTP Hexagon V##

Note

This backend supports Hexagon **v68**, **v69**, **v73**, **v75**, and **v79**.

        - **Step 1:** Set all 3 of the following HTP related environment variables:

            - `QNN_INCLUDE`

setenvvar QNN_INCLUDE "${QNN_SDK_ROOT}/include/QNN"
                    Copy to clipboard
            - `HEXAGON_SDK_ROOT`

Warning

Ensure you’re editing `<path-to-hexagon-sdk>` and replacing it with the path to the root of your local [Hexagon SDK](https://www.qualcomm.com/developer/software/hexagon-npu-sdk#hexagon).

setenvvar HEXAGON_SDK_ROOT "<path-to-hexagon-sdk>"
                    Copy to clipboard
            - `HEXAGON_VERSION`

Note

Edit `68` below with your target version of Hexagon.

setenvvar HEXAGON_VERSION "68"
                    Copy to clipboard
        - **Step 2:** Enter the `OpPackage/HTP` directory

cd ${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP
                Copy to clipboard
        - **Step 3:** Build the package

make htp_v${HEXAGON_VERSION}
                Copy to clipboard

            This will produce an Op Package library which can be checked via the `file` command:

file "${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP/build/hexagon-v${HEXAGON_VERSION}/libQnnHtpOpPackageExample.so"
                Copy to clipboard
        - **Step 4:** Save the Op Package path to `QNN_OP_PACKAGE` for later

setenvvar QNN_OP_PACKAGE "${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP/build/hexagon-v${HEXAGON_VERSION}/libQnnHtpOpPackageExample.so"
                Copy to clipboard
    - **Sub-Option 3:** HTP ARM

        - **Step 1:** The Android NDK Toolchain is required for this section. If you have not installed it already, do so by running these commands:

> 
> 
> # Download the Android NDK
>                 wget https://dl.google.com/android/repository/android-ndk-r26c-linux.zip
>                 # Unzip the NDK.
>                 unzip android-ndk-r26c-linux.zip
>                 # Add ANDROID_NDK_ROOT to your exports.
>                 echo "export ANDROID_NDK_ROOT='$(pwd)/android-ndk-r26c'" >> ~/.bashrc
>                 # Add ANDROID_NDK_ROOT to your PATH.
>                 echo 'export PATH="${ANDROID_NDK_ROOT}:${PATH}"' >> ~/.bashrc
>                 # Reload ~/.bashrc.
>                 source ~/.bashrc
>                 # Verify your environment variables.
>                 ${QNN_SDK_ROOT}/bin/envcheck -n
>                 Copy to clipboard
        - **Step 2:** Set HTP related environment variables

            - `QNN_INCLUDE`

setenvvar QNN_INCLUDE "${QNN_SDK_ROOT}/include/QNN"
                    Copy to clipboard
        - **Step 3:** Enter the `OpPackage/HTP` directory

cd ${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP
                Copy to clipboard
        - **Step 4:** Build the package

make htp_aarch64
                Copy to clipboard

            This will produce an Op Package library which can be checked via the `file` command:

file "${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP/build/aarch64-android/libQnnHtpOpPackageExample.so"
                Copy to clipboard
        - **Step 5:** Save the Op Package path to `QNN_OP_PACKAGE` for later

setenvvar QNN_OP_PACKAGE "${QNN_SDK_ROOT}/examples/QNN/OpPackage/HTP/build/aarch64-android/libQnnHtpOpPackageExample.so"
                Copy to clipboard
- **Option 4:** DSP Backend

    - **Step 1:** Set all of the following DSP related environment variables:

        - `QNN_INCLUDE`

setenvvar QNN_INCLUDE "${QNN_SDK_ROOT}/include/QNN"
                Copy to clipboard
        - `HEXAGON_SDK_ROOT`

setenvvar HEXAGON_SDK_ROOT "<path-to-hexagon-sdk>"
                Copy to clipboard
    - **Step 2:** Enter the `OpPackage/DSP` directory

cd ${QNN_SDK_ROOT}/examples/QNN/OpPackage/DSP
            Copy to clipboard
    - **Step 3:** Build the package

make
            Copy to clipboard

        This will produce an Op Package library which can be checked via the `file` command:

file "${QNN_SDK_ROOT}/examples/QNN/OpPackage/DSP/build/DSP/libQnnDspOpPackageExample.so"
            Copy to clipboard
    - **Step 4:** Save the Op Package path to `QNN_OP_PACKAGE` for later

setenvvar QNN_OP_PACKAGE "${QNN_SDK_ROOT}/examples/QNN/OpPackage/DSP/build/DSP/libQnnDspOpPackageExample.so"
            Copy to clipboard

## Part 2: Build a Model

In order to execute an inference using your model on your target device, you need to convert it into a format that your target device can interpret.

In this section we’ll build a model for use with QNN.

Choose which type of model / conversion you would like to do, your options are:

1. Use the example pre-converted Tensorflow model **(this skips the conversion steps)**
2. Build with an example ONNX Model (Recommended to see the conversion steps)
3. Build your own model or use a pre-built model (ex. Tensorflow, PyTorch)

Skim to the **Option** you chose below and follow all steps within:

- **Option 1:** Use the example pre-converted Tensorflow model **(this skips the conversion steps)**

    Choose the option that corresponds with your target device’s OS and architecture:

    - **Sub-Option 1:** Linux (x86\_64)

        - **Step 1:** Build

${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-model-lib-generator \
                  -c ${QNN_SDK_ROOT}/examples/QNN/converter/models/qnn_model_float.cpp \
                  -b ${QNN_SDK_ROOT}/examples/QNN/converter/models/qnn_model_float.bin \
                  -o ${QNN_SDK_ROOT}/examples/QNN/example_libs \
                  -t x86_64-linux-clang
                Copy to clipboard

            This will produce a model library which can be checked via the `file` command:

file "${QNN_SDK_ROOT}/examples/QNN/example_libs/x86_64-linux-clang/libqnn_model_float.so"
                Copy to clipboard

            You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/QNN/example_libs/x86_64-linux-clang/libqnn_model_float.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=d1418529133bd47dd700990f1c1dc851aabfa5aa, stripped
                Copy to clipboard
        - **Step 2:** Save model path

setenvvar QNN_MODEL_PATH "${QNN_SDK_ROOT}/examples/QNN/example_libs/x86_64-linux-clang/libqnn_model_float.so"
                Copy to clipboard
        - **Step 3:** Save input list path

setenvvar QNN_INPUT_LIST "${QNN_SDK_ROOT}/examples/QNN/converter/models/input_list_float.txt"
                Copy to clipboard
    - **Sub-Option 2:** Android (aarch64)

        - **Step 1:** Build

${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-model-lib-generator \
                  -c ${QNN_SDK_ROOT}/examples/QNN/converter/models/qnn_model_float.cpp \
                  -b ${QNN_SDK_ROOT}/examples/QNN/converter/models/qnn_model_float.bin \
                  -o ${QNN_SDK_ROOT}/examples/QNN/example_libs \
                  -t aarch64-android
                Copy to clipboard

            This will produce a model library which can be checked via the `file` command:

file "${QNN_SDK_ROOT}/examples/QNN/example_libs/aarch64-android/libqnn_model_float.so"
                Copy to clipboard

            You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/QNN/example_libs/aarch64-android/libqnn_model_float.so: ELF 64-bit LSB shared object, ARM aarch64, version 1 (SYSV), dynamically linked, BuildID[sha1]=6d82f8ab9fdd8cfd7147fd314ad69a0aa0875f0a, stripped
                Copy to clipboard
        - **Step 2:** Save model path

setenvvar QNN_MODEL_PATH "${QNN_SDK_ROOT}/examples/QNN/example_libs/aarch64-android/libqnn_model_float.so"
                Copy to clipboard
        - **Step 3:** Save input list path

setenvvar QNN_INPUT_LIST "${QNN_SDK_ROOT}/examples/QNN/converter/models/input_list_float.txt"
                Copy to clipboard
- **Option 2:** Build with an example ONNX Model

    - **Step 1:** Enter the models directory

cd ${QNN_SDK_ROOT}/examples/Models
            Copy to clipboard
    - **Step 2:** Install numpy, onnx, aimet\_onnx, onnxsim, and pandas.

pip3 install numpy onnx aimet_onnx onnxsim pandas
            Copy to clipboard
    - **Step 3:** Obtain an ONNX Model

        You can use whichever model you want, but as an example this guide uses [EfficientNet Lite](https://github.com/onnx/models/tree/main/validated/vision/classification/efficientnet-lite4/model). You’ll likely want a packaged model (like `.tar.gz` or `.zip`) to have access to both the model files and sample input data.

        - **Step 3.1:** Grab the download link for [EfficientNet Lite](https://github.com/onnx/models/tree/main/validated/vision/classification/efficientnet-lite4/model)

            1. Navigate to [EfficientNet Lite](https://github.com/onnx/models/tree/main/validated/vision/classification/efficientnet-lite4/model) in your web browser.
            2. Left-click `efficientnet-lite4-11.tar.gz`.
            3. Right-click “Raw” in the top-right and click “Copy link address”.
        - **Step 3.2:** Download the model using wget.

wget https://github.com/onnx/models/raw/refs/heads/main/validated/vision/classification/efficientnet-lite4/model/efficientnet-lite4-11.tar.gz
                Copy to clipboard
        - **Step 3.3:** Extract the model package.

tar -xf *.tar.gz
                Copy to clipboard
    - **Step 4:** Save model path to an environment variable

        In this step we want to save the model path to an environment variable for future use. This is the file that ends in `.onnx`.

setenvvar ONNX_MODEL_PATH "${QNN_SDK_ROOT}/examples/Models/efficientnet-lite4/efficientnet-lite4.onnx"
            Copy to clipboard
    - **Step 5:** Get model dimensions and name

        - **Step 5.1:** Retrieve model dimensions and name

            Run this script to get the input name and dimensions

python3 -c "import os, onnx, onnxruntime; \
                f = os.environ['ONNX_MODEL_PATH']; \
                m = onnx.load(f); \
                s = onnxruntime.InferenceSession(f); \
                lines = [f'ONNX Input: name={i.name}, shape={[d.dim_value for d in i.type.tensor_type.shape.dim]}\n' for i in m.graph.input]
                print(''.join(lines), end=''); \
                open('input_name_and_dim.txt', 'w').writelines(lines)"
                Copy to clipboard

            You can access these values later by looking at `input_name_and_dim.txt`
        - **Step 5.2:** Save model dimensions and name to environment variables

eval $(sed -n 's/ONNX Input: name=\([^,]*\), shape=\[\(.*\)\]/setenvvar ONNX_INPUT_NAME "\1"; setenvvar ONNX_INPUT_DIMENSIONS "\2"/p' ${ONNX_MODEL_PATH%/*}/input_name_and_dim.txt)
                Copy to clipboard

            You should see the following output:

ONNX_INPUT_NAME set to images:0
                ONNX_INPUT_DIMENSIONS set to 1, 224, 224, 3
                Copy to clipboard
    - **Step 6:** Create input\_list.txt

        For running the model and performing quantized conversions we need input data. The QNN tools expect this data to be in a raw format, and the paths defined in a text file.

        - **Step 6.1:** Convert inputs to raw

            If your input data is in Protobuf format (`*.pb`) it’s going to need to be converted.

Note

This script assumes data in a path of `${ONNX_MODEL_PATH%/*}/test_data_set_*/input_0.pb`, edit it to suit your path if needed.

python3 -c '
                import onnx, numpy as np, struct, glob, os
                onnx_model_path = os.environ["ONNX_MODEL_PATH"]
                base_dir = os.path.dirname(onnx_model_path)
                pattern = os.path.join(base_dir, "test_data_set_*/input_0.pb")
                
                for pb in glob.glob(pattern):
                    tensor = onnx.TensorProto()
                    with open(pb, "rb") as f:
                        tensor.ParseFromString(f.read())
                    arr = onnx.numpy_helper.to_array(tensor).astype(np.float32)
                    raw_path = os.path.splitext(pb)[0] + ".raw"
                    arr.tofile(raw_path)
                    print("Wrote", raw_path, arr.shape, arr.nbytes, "bytes")
                '
                Copy to clipboard

            You should see the following output:

Wrote /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/test_data_set_0/input_0.raw (1, 224, 224, 3) 602112 bytes
                Wrote /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/test_data_set_2/input_0.raw (1, 224, 224, 3) 602112 bytes
                Wrote /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/test_data_set_1/input_0.raw (1, 224, 224, 3) 602112 bytes
                Copy to clipboard
        - **Step 6.2:** Create a file containing every input path

ls -la "${ONNX_MODEL_PATH%/*}" | grep '^d' | awk '{print $9}' | grep -vE '^\.\.?$' | awk -v dir="${ONNX_MODEL_PATH%/*}" '{print dir "/" $0 "/input_0.raw"}' > "${ONNX_MODEL_PATH%/*}/input_list.txt"
                Copy to clipboard
        - **Step 6.3:** Save `input_list.txt` to an environment variable

setenvvar QNN_INPUT_LIST "${ONNX_MODEL_PATH%/*}/input_list.txt"
                Copy to clipboard
    - **Step 7:** Convert the model

        In this step you must decide if you’d like full precision (usually 32bit) or quantized (usually 8 or 16bit). Some platforms like DSP only work with quantized models, what you want will generally depend on your use-case.

        Choose whether you want to use full precision (32bit) or if you want to quantize your model (required for DSP and HTP target backends, optional for others):

        - **Option 1:** Full Precision

            - **Step 7.1:** Convert the model

${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-onnx-converter \
                      --input_network "${ONNX_MODEL_PATH}" \
                      -d "${ONNX_INPUT_NAME}" "${ONNX_INPUT_DIMENSIONS}" \
                      -l "${ONNX_INPUT_NAME}" NHWC \
                      --output_path "${ONNX_MODEL_PATH%.*}_qnn_model.cpp"
                    Copy to clipboard
            - **Step 7.2:** Save path to model for later use

Note

We don’t want to save the file extension as we’ll be using the variable to reference both the `.bin` and `.cpp` files.

setenvvar ONNX_CONVERTED_PATH "${ONNX_MODEL_PATH%.*}_qnn_model"
                    Copy to clipboard

                You should see the following output:

ONNX_CONVERTED_PATH set to /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/efficientnet-lite4_qnn_model
                    Copy to clipboard
        - **Option 2:** Quantized (Required for DSP and HTP backends)

            - **Step 7.1:** Run the quantized conversion

${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-onnx-converter \
                      --input_network "${ONNX_MODEL_PATH}" \
                      --input_list "${ONNX_MODEL_PATH%/*}/input_list.txt" \
                      -d "${ONNX_INPUT_NAME}" "${ONNX_INPUT_DIMENSIONS}" \
                      --weights_bitwidth 8 \
                      --act_bitwidth 8 \
                      --output_path "${ONNX_MODEL_PATH%.*}_qnn_quantized_model.cpp" \
                      --float_bitwidth 16
                    Copy to clipboard
            - **Step 7.2:** Save path to model for later use

                We don’t want to save the file extension as we’ll be using the variable to reference both the `.bin` and `.cpp` files.

setenvvar ONNX_CONVERTED_PATH "${ONNX_MODEL_PATH%.*}_qnn_quantized_model"
                    Copy to clipboard

                You should see the following output:

ONNX_CONVERTED_PATH set to /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/efficientnet-lite4_qnn_model
                    Copy to clipboard
    - **Step 8:** Build your model for your target device

        - **Step 8.1:** Build the model library

python3 "${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-model-lib-generator" \
                    -c "${ONNX_CONVERTED_PATH}.cpp" \
                    -b "${ONNX_CONVERTED_PATH}.bin" \
                    -o "${ONNX_MODEL_PATH%/*}**/**model_libs" \
                    -t ${QNN_TARGET_ARCH_AND_OS}
                Copy to clipboard

            This will produce a model library which can be checked via the `file` command:

file "${ONNX_MODEL_PATH%/*}**/**model_libs/${QNN_TARGET}**/libefficientnet-lite4_qnn_model.so**"
                Copy to clipboard

            You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/model_libs/x86_64-linux-clang/libefficientnet-lite4_qnn_model.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=e01f1bdc899414b3c4abfc7730b19ca295b4f577, stripped
                Copy to clipboard
        - **Step 8.2:** Save model path

setenvvar QNN_MODEL_PATH "${ONNX_MODEL_PATH%/*}**/**model_libs/${QNN_TARGET_ARCH_AND_OS}**/libefficientnet-lite4_qnn_model.so**"
                Copy to clipboard

            You should see the following output:

QNN_MODEL_PATH set to /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/model_libs/x86_64-linux-clang/libefficientnet-lite4_qnn_model.so
                Copy to clipboard
- **Option 3:** Build your own model or use a pre-built model (ex. Tensorflow, PyTorch)

Note

If you have already converted your model (ex. because you followed the steps in the [CNN to QNN tutorial](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/tutorial_convert_execute_cnn_model.html)), still follow the below steps 1-6 and step 8.4 to set the `QNN_MODEL_PATH` variable.

- **Step 1:** Enter the models directory

cd ${QNN_SDK_ROOT}/examples/Models
        Copy to clipboard
- **Step 2:** Install dependencies

    - **Step 2.1:** Install numpy and pandas (required by most model frameworks).

pip3 install numpy pandas
            Copy to clipboard
    - **Step 2.2:** Choose which version of AIMET you need based on your model:

        | Framework | Package Name | Notes |
        | --- | --- | --- |
        | PyTorch | [aimet-torch](https://pypi.org/project/aimet-torch/) |  |
        | ONNX | [aimet-onnx](https://pypi.org/project/aimet-onnx/) |  |
        | Tensorflow | [aimet-tensorflow](https://pypi.org/project/aimet-tensorflow/) | You may need to directly install the Tensorflow version of [AIMET from GitHub](https://github.com/quic/aimet/releases). |
    - **Step 2.3:** Install the aimet version you need, for example:

pip3 install aimet-torch
            Copy to clipboard
    - **Step 2.4:** Choose which framework files are relevant to you:

        | Package | Version | Description |
        | --- | --- | --- |
        | [PyTorch (torch)](https://pypi.org/project/torch/) | 1.13.1 | PyTorch is used for building and training deep learning models with a focus on flexibility and speed. Used with .pt files. **Install by downloading the proper binary `here <https://pytorch.org/get-started/previous-versions/#v1130>`\_\_ if pip install does not work.** |
        | [Torchvision (torchvision)](https://pypi.org/project/torchvision/) | 0.14.1 | Torchvision is used for computer vision tasks with PyTorch, providing datasets, model architectures, and image transforms. |
        | [TensorFlow (tensorflow)](https://pypi.org/project/tensorflow/) | 2.10.1 | Tensorflow is used for building and training machine learning models, particularly deep learning models. Used with .pb files. NOTE: The `envcheck` script will incorrectly say this file is not installed on Ubuntu. |
        | [TFLite (tflite)](https://pypi.org/project/tflite/) | 2.3.0 | TFLite is used for running TensorFlow models on mobile and edge devices with optimized performance. Used with .tflite files. |
        | [ONNX (onnx)](https://pypi.org/project/onnx/) | 1.12.0 | ONNX stands for Open Neural Network Exchange. It is used for defining and exchanging deep learning models between different frameworks. Used with .onnx files. |
        | [ONNX Runtime (onnxruntime)](https://pypi.org/project/onnxruntime/) | 1.17.1 | ONNX stands for Open Neural Network Exchange. It is used for running ONNX models with high performance across various hardware platforms. Used with .onnx files. |
        | [ONNX Simplifier (onnxsim)](https://pypi.org/project/onnxsim/) | 0.4.36 | Onnxsim is used for simplifying ONNX models to reduce complexity and improve inference efficiency. Used with .onnx files. |
    - **Step 2.5:** Install the framework specific packages from above, for example:

pip3 install tensorflow
            Copy to clipboard
- **Step 3:** Obtain Your Model

    You will need to install both your model file and input data to test with. You can [find models here](https://aihub.qualcomm.com/ecosystem) or bring your own. You’ll likely want a packaged model (like `.tar.gz` or `.zip`) to have access to sample input data.

    - **Step 3.1:** Download the model, for example:

wget https://github.com/onnx/models/raw/refs/heads/main/validated/vision/classification/efficientnet-lite4/model/efficientnet-lite4-11.tar.gz
            Copy to clipboard
    - **Step 3.2:** Extract the model.
    - **Step 3.3:** Download any test data you will want to use.
- **Step 4:** Save model path to an environment variable

    In this step we want to save the model path to an environment variable for future use. This is the file that ends in `.onnx`.

setenvvar MODEL_PATH "${QNN_SDK_ROOT}/examples/Models/efficientnet-lite4/efficientnet-lite4.onnx"
        Copy to clipboard
- **Step 5:** Get model dimensions and name

    Later we will need the model dimensions (ex. `1,299,299,1` for our Tensorflow example) and the name of the layer we want to output during inference (ex. `Reshape_1`). The way to identify these values varies from framework to framework. So, we recommend you use AI to generate a script to help inspect your model files (or hand-code an interpreter using the model framework package).

    - **Step 5.1:** Generate code to inspect your model’s dimensions and layer names.

        - **Step 5.1.1:** Update the “MODEL FRAMEWORK” value and copy this into an AI chat (like ChatGPT) to generate a script you can use to inspect your model:

MODEL FRAMEWORK: <INSERT MODEL FRAMEWORK HERE>
                TARGET OS TO RUN THIS IN: Linux (Ubuntu)
                
                Please generate a python script to inspect the model dimensions and layers for my model file that is using the MODEL FRAMEWORK specified above.
                Use the same environment variables as in the example below - they will be set to the proper values for my model.
                Also use the same output file.
                
                Here is an example of how this script should be implemented for ONNX:
                python3 -c "import os, onnx, onnxruntime; \
                f = os.environ['MODEL_PATH']; \
                m = onnx.load(f); \
                s = onnxruntime.InferenceSession(f); \
                lines = [f'Input: name={i.name}, shape={[d.dim_value for d in i.type.tensor_type.shape.dim]}\n' for i in m.graph.input]
                print(''.join(lines), end=''); \
                open('input_name_and_dim.txt', 'w').writelines(lines)"
                Copy to clipboard
        - **Step 5.1.2:** Run your script to inspect your model file.

            You should be able to find the name and shape later by looking at `input_name_and_dim.txt`.
    - **Step 5.2:** Save model dimensions and name to environment variables

eval $(sed -n 's/Input: name=\([^,]*\), shape=\[\(.*\)\]/setenvvar INPUT_NAME "\1"; setenvvar INPUT_DIMENSIONS "\2"/p' ${MODEL_PATH%/*}/input_name_and_dim.txt)
            Copy to clipboard

        You should see the following output:

INPUT_NAME set to images:0
            INPUT_DIMENSIONS set to 1, 224, 224, 3
            Copy to clipboard
- **Step 6:** Create `input_list.txt`

    For running the model and performing quantized conversions we need input data. The QNN tools expect this data to be in a raw format, and the paths defined in a text file.

    - **Step 6.1:** Convert inputs to .raw (Optional - may be needed if your inputs are not .raw files)

        This is only required if your input files are protobuf files (`.pb`).

        - **Step 6.1.1:** Update the “MODEL FRAMEWORK” value and copy this into an AI chat (like ChatGPT) to generate a script you can use to convert your input data:

MODEL FRAMEWORK: <INSERT MODEL FRAMEWORK HERE>
                TEST_DATA_FORMAT: test_data_set_*/input_0.pb
                TARGET OS TO RUN THIS IN: Linux (Ubuntu)
                
                Please generate a python script to convert input files for my model located at TEST_DATA_FORMAT into the .raw format..
                Use the same environment variables as in the example below - they will be set to the proper values for my model.
                Also use the same output file.
                
                Here is an example of how this script should be implemented for ONNX:
                python3 -c '
                import onnx, numpy as np, struct, glob, os
                model_path = os.environ["MODEL_PATH"]
                base_dir = os.path.dirname(model_path)
                pattern = os.path.join(base_dir, "test_data_set_*/input_0.pb")
                
                for pb in glob.glob(pattern):
                    tensor = onnx.TensorProto()
                    with open(pb, "rb") as f:
                        tensor.ParseFromString(f.read())
                    arr = onnx.numpy_helper.to_array(tensor).astype(np.float32)
                    raw_path = os.path.splitext(pb)[0] + ".raw"
                    arr.tofile(raw_path)
                    print("Wrote", raw_path, arr.shape, arr.nbytes, "bytes")
                '
                Copy to clipboard
    - **Step 6.2:** Create an `input_list.txt` file containing every input path

        We need to create a list of inputs (`input_list.txt`) to use for quantization. The following command assumes all directories are input directories containing “input\_0.raw”, outputs list to `input_list.txt`:

ls -la "${MODEL_PATH%/*}" | grep '^d' | awk '{print $9}' | grep -vE '^\.\.?$' | awk -v dir="${MODEL_PATH%/*}" '{print dir "/" $0 "/input_0.raw"}' > "${MODEL_PATH%/*}/input_list.txt"
            Copy to clipboard
    - **Step 6.3:** Save `input_list.txt` to an environment variable

setenvvar QNN_INPUT_LIST "${MODEL_PATH%/*}/input_list.txt"
            Copy to clipboard
- **Step 7:** Convert the model

    In this step you must decide if you’d like full precision (usually 32bit) or quantized (usually 8 or 16bit). For DSP and HTP, you MUST use quantized models. Besides that, what you want will generally depend on your use-case.

    - **Option 1:** Full Precision

        - **Step 7.1:** Choose the right converter for your situation

            - **Step 7.1.1:** Based on your model framework, choose which tool matches:

                | Model Framework | Tool Name | Link to docs |
                | --- | --- | --- |
                | ONNX | qnn-onnx-converter | [Link](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/tools.html#qnn-onnx-converter) |
                | PyTorch | qnn-pytorch-converter | [Link](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/tools.html#qnn-pytorch-converter) |
                | TensorFlow | qnn-tensorflow-converter | [Link](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/tools.html#qnn-tensorflow-converter) |
                | TensorFlow Lite | qnn-tflite-converter | [Link](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/tools.html#qnn-tflite-converter) |
                | Other | See the Tools page for other options | [Link](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/tools.html) |
            - **Step 7.1.2:** Set an environment variable with the tool name by running:

setenvvar QNN_CONVERTER "your_converter_name"
                    Copy to clipboard
        - **Step 7.2:** Convert the model

${QNN_SDK_ROOT}/bin/x86_64-linux-clang/${QNN_CONVERTER} \
                  --input_network "${MODEL_PATH}" \
                  -d "${INPUT_NAME}" "${INPUT_DIMENSIONS}" \
                  -l "${INPUT_NAME}" NHWC \
                  --output_path "${MODEL_PATH%.*}_qnn_model.cpp"
                Copy to clipboard
        - **Step 7.3:** Save path to model for later use

Note

We don’t want to save the file extension as we’ll be using the variable to reference both the `.bin` and `.cpp` files.

setenvvar CONVERTED_PATH "${MODEL_PATH%.*}_qnn_model"
                Copy to clipboard

            You should see the following output:

CONVERTED_PATH set to /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/efficientnet-lite4_qnn_model
                Copy to clipboard
    - **Option 2:** Quantized

        - **Step 7.1:** Run the quantized conversion

${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-onnx-converter \
                  --input_network "${MODEL_PATH}" \
                  --input_list "${MODEL_PATH%/*}/input_list.txt" \
                  -d "${INPUT_NAME}" "${INPUT_DIMENSIONS}" \
                  --weights_bitwidth 8 \
                  --act_bitwidth 8 \
                  --output_path "${MODEL_PATH%.*}_qnn_quantized_model.cpp" \
                  --float_bitwidth 16
                Copy to clipboard
        - **Step 7.2:** Save path to model for later use

            We don’t want to save the file extension as we’ll be using the variable to reference both the `.bin` and `.cpp` files.

setenvvar CONVERTED_PATH "${MODEL_PATH%.*}_qnn_quantized_model"
                Copy to clipboard

            You should see the following output:

CONVERTED_PATH set to /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/efficientnet-lite4_qnn_model
                Copy to clipboard
- **Step 8:** Build your model for your target device

    - **Step 8.1:** Grab the appropriate “target” for your target architecture / platform

        | Target | Architecture | OS/Platform | Toolchain |
        | --- | --- | --- | --- |
        | `x86_64-linux-clang` | x86\_64 (64-bit) | Linux | Clang |
        | `aarch64-android` | ARM64 | Android | Android NDK toolchain |
        | `aarch64-qnx` | ARM64 | QNX | QNX SDK toolchain |
        | `aarch64-oe-linux-gcc11.2` | ARM64 | OpenEmbedded Linux | GCC 11.2 |
        | `aarch64-oe-linux-gcc9.3` | ARM64 | OpenEmbedded Linux | GCC 9.3 |
        | `aarch64-oe-linux-gcc8.2` | ARM64 | OpenEmbedded Linux | GCC 8.2 |
        | `aarch64-ubuntu-gcc9.4` | ARM64 | Ubuntu Linux | GCC 9.4 |
        | `aarch64-ubuntu-gcc7.5` | ARM64 | Ubuntu Linux | GCC 7.5 |
    - **Step 8.2:** Save the target to an environment variable

        Ensure you’re using the value you obtained from **Step 7.1** here.

setenvvar QNN_TARGET "x86_64-linux-clang"
            Copy to clipboard
    - **Step 8.3:** Build the model library

python3 "${QNN_SDK_ROOT}/bin/x86_64-linux-clang/qnn-model-lib-generator" \
                -c "${CONVERTED_PATH}.cpp" \
                -b "${CONVERTED_PATH}.bin" \
                -o "${MODEL_PATH%/*}**/**model_libs" \
                -t ${QNN_TARGET}
            Copy to clipboard

        This will produce a model library which can be checked via the `file` command:

file "${MODEL_PATH%/*}**/**model_libs/${QNN_TARGET}**/libefficientnet-lite4_qnn_model.so**"
            Copy to clipboard

        You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/model_libs/x86_64-linux-clang/libefficientnet-lite4_qnn_model.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=e01f1bdc899414b3c4abfc7730b19ca295b4f577, stripped
            Copy to clipboard
    - **Step 8.4:** Save model path

setenvvar QNN_MODEL_PATH "${MODEL_PATH%/*}**/**model_libs/${QNN_TARGET}**/libefficientnet-lite4_qnn_model.so**"
            Copy to clipboard

        You should see something like the following output:

QNN_MODEL_PATH set to /home/qnn/qairt/2.36.0.250627/examples/Models/efficientnet-lite4/model_libs/x86_64-linux-clang/libefficientnet-lite4_qnn_model.so
            Copy to clipboard

## Part 3: Build the QNN Sample App

Now that our environment’s setup, we have the Op Package, and an example model, we’re ready to build the QNN Sample App. The app is installed as part of downloading the QNN SDK.

- **Step 1:** Enter the `Sample App` example directory

cd ${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App
        Copy to clipboard
- **Step 2:** Build the app by following the instructions for one of the below target device architectures:

    - **Option 1:** Linux (x86\_64)

make all_x86
            Copy to clipboard

        This will produce a model library which can be checked via the `file` command:

file "${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/x86_64-linux-clang/qnn-sample-app"
            Copy to clipboard

        You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/QNN/Sample App/Sample App/bin/x86_64-linux-clang/qnn-sample-app: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=caf1c3dd8976d65cd655e2c0f63e16ca5d226772, for GNU/Linux 3.2.0, not stripped
            Copy to clipboard
    - **Option 2:** Android (aarch64)

make all_android
            Copy to clipboard

        This will produce a model library which can be checked via the `file` command:

file "${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/aarch64-android/qnn-sample-app"
            Copy to clipboard

        You should see something like:

/home/qnn/qairt/2.36.0.250627/examples/QNN/Sample App/Sample App/bin/aarch64-android/qnn-sample-app: ELF 64-bit LSB pie executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /system/bin/linker64, BuildID[sha1]=ae36a11b2a42c6640dc74e4a27ba9681e5ae68d3, stripped
            Copy to clipboard

## Part 4: Moving the app and binaries to the target device

In this part we’re going to use `rsync` over SSH to transfer files between your devices. Your target device must be running an SSH server, and you’ll need the following:

- Target device IP address
- Target device username
- Target device password
- **Step 1:** Enter input\_list directory

cd ${QNN_INPUT_LIST%/*}
        Copy to clipboard
- **Step 2:** Set environment variables based on your target device’s OS:

    - **Option 1:** Linux (SSH)

        In this step you’ll set your target machine’s IP and username for transferring later, as well as the destination path. The target user will need SSH access. Ensure you’re replacing the `*_GOES_HERE` snippets with your info.

setenvvar QNN_TARGET_ADDR TARGET_IP_GOES_HERE
            setenvvar QNN_TARGET_USER TARGET_USER_GOES_HERE
            setenvvar QNN_TARGET_DEST /tmp/qnn
            Copy to clipboard
    - **Option 2:** Android (adb)

        For Android we only need to set the target for our sample app and related binaries.

setenvvar QNN_TARGET_DEST /data/local/tmp/qnn
            Copy to clipboard
- **Step 3:** Create new input\_list file

    We’re moving our files to a new location, this new input\_list will contain our new paths.

Note

This assumes that the input data is in the same directory as your input list. If you have data in sub-folders, you will need to modify this.

awk -F'/' -v dest="$QNN_TARGET_DEST" '{print dest "/" $(NF-1) "/" $NF}' input_list.txt > input_list_target.txt
        Copy to clipboard
- **Step 4**: Create environment variable file for target

    We need to create an environment variable file to locate our files on the new machine.

echo "export QNN_INPUT_LIST=${QNN_TARGET_DEST}/input_list_target.txt" > ./target_env_vars.env
        echo "export QNN_SAMPLE_APP=${QNN_TARGET_DEST}/qnn-sample-app" >> ./target_env_vars.env
        echo "export QNN_MODEL_PATH=${QNN_TARGET_DEST}/${QNN_MODEL_PATH##*/}" >> ./target_env_vars.env
        echo "export QNN_OP_PACKAGE=${QNN_TARGET_DEST}/${QNN_OP_PACKAGE##*/}" >> ./target_env_vars.env
        Copy to clipboard
- **Step 5:** Move files to target device

Note

The following section assumes your input data is within the same directory as your `input_list.txt`.

    Pick the proper OS based on your target device:

    - **Option 1:** Linux

        Pick which of the following target backends you are planning on running the sample app on:

        - **Sub-Option 1:** CPU / x86\_64

rsync -av $(awk -F'/' '{print $(NF-1)}' input_list_target.txt) input_list_target.txt target_env_vars.env ${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/${QNN_TARGET_ARCH_AND_OS}/qnn-sample-app ${QNN_SDK_ROOT}/lib/${QNN_TARGET_ARCH_AND_OS}/libQnnCpu.so ${QNN_MODEL_PATH} ${QNN_OP_PACKAGE} ${QNN_TARGET_USER}@${QNN_TARGET_ADDR}:${QNN_TARGET_DEST}
                Copy to clipboard
        - **Sub-Option 2:** GPU

rsync -av $(awk -F'/' '{print $(NF-1)}' input_list_target.txt) input_list_target.txt target_env_vars.env ${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/${QNN_TARGET_ARCH_AND_OS}/qnn-sample-app ${QNN_SDK_ROOT}/lib/${QNN_TARGET_ARCH_AND_OS}/libQnnGpu.so ${QNN_MODEL_PATH} ${QNN_OP_PACKAGE} ${QNN_TARGET_USER}@${QNN_TARGET_ADDR}:${QNN_TARGET_DEST}
                Copy to clipboard
        - **Sub-Option 3:** HTP (x86 Emulation)

rsync -av $(awk -F'/' '{print $(NF-1)}' input_list_target.txt) input_list_target.txt target_env_vars.env ${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/${QNN_TARGET_ARCH_AND_OS}/qnn-sample-app ${QNN_SDK_ROOT}/lib/${QNN_TARGET_ARCH_AND_OS}/libQnnHtp.so ${QNN_MODEL_PATH} ${QNN_OP_PACKAGE} ${QNN_TARGET_USER}@${QNN_TARGET_ADDR}:${QNN_TARGET_DEST}
                Copy to clipboard
        - **Sub-Option 4:** HTP (Hexagon)

rsync -av $(awk -F'/' '{print $(NF-1)}' input_list_target.txt) input_list_target.txt target_env_vars.env ${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/${QNN_TARGET_ARCH_AND_OS}/qnn-sample-app ${QNN_SDK_ROOT}/lib/hexagon-v${HEXAGON_VERSION}/libQnnHtp.so ${QNN_MODEL_PATH} ${QNN_OP_PACKAGE} ${QNN_TARGET_USER}@${QNN_TARGET_ADDR}:${QNN_TARGET_DEST}
                Copy to clipboard
    - **Option 2:** Android

        - **Step 1:** Create and run this script (`android_adb.sh`) to copy over all the files needed via adb for the sample app:

DEST=/data/local/tmp/qnn
                
                # Create the target dir
                adb shell "mkdir -p $DEST"
                
                # Push dirs listed in input_list_target.txt
                for dir in $(awk -F'/' '{print $(NF-1)}' input_list_target.txt | sort -u); do
                  adb push "$dir" "$DEST/"
                done
                
                # Push input_list_target.txt and env file
                adb push input_list_target.txt "$DEST/"
                adb push target_env_vars.env "$DEST/"
                
                # Push Sample App binary and libQnnCpu.so
                adb push "${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/${QNN_TARGET_ARCH_AND_OS}/qnn-sample-app" "$DEST/"
                adb push "${QNN_SDK_ROOT}/lib/${QNN_TARGET_ARCH_AND_OS}/$1" "$DEST/"
                
                # Push model and op package
                adb push "${QNN_MODEL_PATH}" "$DEST/"
                adb push "${QNN_OP_PACKAGE}" "$DEST/"
                Copy to clipboard
        - **Step 2:** Pick which of the following target backends you are planning on running the sample app on:

            - **Sub-Option 1:** CPU

./android_adb.sh libQnnCpu.so
                    Copy to clipboard
            - **Sub-Option 2:** GPU

./android_adb.sh libQnnGpu.so
                    Copy to clipboard
            - **Sub-Option 3:** HTP

./android_adb.sh libQnnHtp.so
                    Copy to clipboard
            - **Sub-Option 4:** DSP

./android_adb.sh libQnnDsp.so
                    Copy to clipboard

## Part 5: Run the QNN Sample App

At this stage we’ll run the app and generate an output. Below are 2 options: **Host** and **Target**.

If you want to test your changes on your host machine, follow the “Host Machine” steps. If you want to run the sample app on your target device, follow the “On your Target Device” steps.

- **Option 1:** On your Host Machine (for testing locally)

    - **Step 1:** Enter the Sample App directory.

cd ${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/
            Copy to clipboard
    - **Step 2:** Run the Sample App.

        Choose based on the target backend you want to run the Sample App on:

        - **Option 1:** CPU

            - **Sub-Option 1:** Linux (x86\_64)

${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/x86_64-linux-clang/qnn-sample-app \
                                  --backend ${QNN_SDK_ROOT}/lib/x86_64-linux-clang/libQnnCpu.so \
                                  --model ${QNN_MODEL_PATH} \
                                  --input_list ${QNN_INPUT_LIST} \
                                  --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                    Copy to clipboard
            - **Sub-Option 2:** Android (aarch64)

${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/aarch64-android/qnn-sample-app \
                                  --backend ${QNN_SDK_ROOT}/lib/aarch64-android/libQnnCpu.so \
                                  --model ${QNN_MODEL_PATH} \
                                  --input_list ${QNN_INPUT_LIST} \
                                  --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                    Copy to clipboard
        - **Option 2:** GPU (aarch64)

Note

For GPU we have the following backends:

            - `libQnnGpuNetRunExtensions.so`
            - `libQnnGpuProfilingReader.so`
            - `libQnnGpu.so`

I’m entirely unsure when we’d use the different backends.

${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/aarch64-android/qnn-sample-app \
                              --backend ${QNN_SDK_ROOT}/lib/aarch64-android/libQnnGpu.so \
                              --model ${QNN_MODEL_PATH} \
                              --input_list ${QNN_INPUT_LIST} \
                              --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                Copy to clipboard
        - **Option 3:** HTP

Note

For HTP we have the following backends:

            - `libHtpPrepare.so`
            - `libQnnHtpNetRunExtensions.so`
            - `libQnnHtpOptraceProfilingReader.so`
            - `libQnnHtpProfilingReader.so`
            - `libQnnHtpQemu.so`
            - `libQnnHtp.so`

            Follow the steps corresponding to the type of HTP system you are working with:

            - **Sub-Option 1:** HTP Emulation (x86\_64)

${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/x86_64-linux-clang/qnn-sample-app \
                                  --backend ${QNN_SDK_ROOT}/lib/x86_64-linux-clang/libQnnHtp.so \
                                  --model ${QNN_MODEL_PATH} \
                                  --input_list ${QNN_INPUT_LIST} \
                                  --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                    Copy to clipboard
            - **Sub-Option 2:** HTP Hexagon V##

Note

This backend supports Hexagon `v68`, `v69`, `v73`, `v75`, and `v79`.

${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/x86_64-linux-clang/qnn-sample-app \
                                  --backend ${QNN_SDK_ROOT}/lib/hexagon-v${HEXAGON_VERSION}/libQnnHtp.so \
                                  --model ${QNN_MODEL_PATH} \
                                  --input_list ${QNN_INPUT_LIST} \
                                  --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                    Copy to clipboard
            - **Option 3:** HTP ARM (aarch64)

${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/aarch64-android/qnn-sample-app \
                                  --backend ${QNN_SDK_ROOT}/lib/aarch64-android/libQnnHtp.so \
                                  --model ${QNN_MODEL_PATH} \
                                  --input_list ${QNN_INPUT_LIST} \
                                  --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                    Copy to clipboard
        - **Option 4:** DSP (aarch64)

Note

For DSP we have the following backends:

            - `libQnnDspNetRunExtensions.so`
            - `libQnnDsp.so`
            - `libQnnDspV66CalculatorStub.so`
            - `libQnnDspV66Stub.so`

${QNN_SDK_ROOT}/examples/QNN/Sample App/Sample App/bin/aarch64-android/qnn-sample-app \
                              --backend ${QNN_SDK_ROOT}/lib/aarch64-android/libQnnDsp.so \
                              --model ${QNN_MODEL_PATH} \
                              --input_list ${QNN_INPUT_LIST} \
                              --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                Copy to clipboard
- **Option 2:** On your Target Device

    Choose which target backend you want to run the Sample App on:

    - **Option 1:** CPU

        - **Step 1:** Install `libc++1`

            This step assumes you’re running Ubuntu 20.04. If not, try heading to **Step 1**.

apt install libc++1
                Copy to clipboard
        - **Step 2:** Enter temporary qnn directory

            In **Part 4** we transferred all our required files into `$QNN_TARGET_DEST`, this destination is different on Linux or Android systems.

            Choose the option based on your target device’s OS:

            - **Sub-Option 1:** Linux

cd /tmp/qnn
                    Copy to clipboard
            - **Sub-Option 2:** Android

cd /data/local/tmp/qnn
                    Copy to clipboard
        - **Step 3:** Load the environment variables

source target_env_vars.env
                Copy to clipboard
        - **Step 4:** Run the sample app

./qnn-sample-app \
                              --backend ./libQnnCpu.so \
                              --model ${QNN_MODEL_PATH} \
                              --input_list ${QNN_INPUT_LIST} \
                              --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                Copy to clipboard
    - **Option 2:** GPU

        - **Step 1:** Enter temporary qnn directory

cd /data/local/tmp/qnn
                Copy to clipboard
        - **Step 2:** Load the environment variables

source target_env_vars.env
                Copy to clipboard
        - **Step 3:** Run the sample app

./qnn-sample-app \
                              --backend ./libQnnGpu.so \
                              --model ${QNN_MODEL_PATH} \
                              --input_list ${QNN_INPUT_LIST} \
                              --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                Copy to clipboard
    - **Option 3:** HTP

        - **Step 1:** Enter temporary qnn directory

            In **Part 4** we transferred all our required files into `$QNN_TARGET_DEST`, this destination is different on Linux or Android systems.

            Choose the option based on your target device’s OS:

            - **Option 1:** Linux

cd /tmp/qnn
                    Copy to clipboard
            - **Option 2:** Android

cd /data/local/tmp/qnn
                    Copy to clipboard
        - **Step 2:** Load the environment variables

source target_env_vars.env
                Copy to clipboard
        - **Step 3:** Run the sample app

./qnn-sample-app \
                              --backend ./libQnnHtp.so \
                              --model ${QNN_MODEL_PATH} \
                              --input_list ${QNN_INPUT_LIST} \
                              --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                Copy to clipboard
    - **Option 4:** DSP

        - **Step 1:** Enter temporary qnn directory

cd /data/local/tmp/qnn
                Copy to clipboard
        - **Step 2:** Load the environment variables

source target_env_vars.env
                Copy to clipboard
        - **Step 3:** Run the sample app

./qnn-sample-app \
                              --backend ./libQnnDsp.so \
                              --model ${QNN_MODEL_PATH} \
                              --input_list ${QNN_INPUT_LIST} \
                              --op_packages ${QNN_OP_PACKAGE}:QnnOpPackage_interfaceProvider
                Copy to clipboard

## Conclusion

With that, you have successfully ran the Sample App on your target device!

The next steps are to:

1. Inspect the source code for the Sample App in order to understand how it uses the QNN API to interact with your model.
2. Integrate similar logic into your on-target application to use your model.

    1. You can also build off of the Sample App if you don’t have a pre-existing application.

You will likely need to leverage the API section to look up what various functions do.

Last Published: Oct 10, 2025

[Previous Topic
CNN to QNN for Windows Host](https://docs.qualcomm.com/bundle/publicresource/80-63442-50/topics/qnn_tutorial_windows_host.md) [Next Topic
Sample App Tutorial](https://docs.qualcomm.com/bundle/publicresource/80-63442-50/topics/sample_app.md)