# Running the Word-RNN Model

Overview

The example C++ application in this tutorial is called
[snpe-net-run](https://docs.qualcomm.com/doc/80-63442-2/topic/tools.html#snpe-net-run). It is a command line executable that executes
a neural network using Qualcomm® Neural Processing SDK APIs.

The required arguments to snpe-net-run are:

- A neural network model in the DLC file format
- An input list file with paths to the input data.

Optional arguments to snpe-net-run are:

- Choice of GPU or DSP runtime (default is CPU)
- Output directory (default is ./output)
- Show help description

snpe-net-run creates and populates an output directory with the
results of executing the neural network on the input data.

![../images/neural_network.png](data:image/png;base64,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)

The Qualcomm® Neural Processing SDK provides Linux and Android binaries of
**snpe-net-run** under

- $SNPE\_ROOT/bin/x86\_64-linux-clang
- $SNPE\_ROOT/bin/aarch64-android
- $SNPE\_ROOT/bin/aarch64-oe-linux-gcc8.2
- $SNPE\_ROOT/bin/aarch64-oe-linux-gcc9.3

Introduction

Recurrent Neural Network (RNN) architectures are widely used in
Machine Learning Applications for processing sequential input
data. This chapter will show a simple Word-RNN example for
predicting the next word in an embedding using Long Short-Term
Memory (LSTM). The step-by-step example will create, train,
convert, and execute a Word-RNN model with Qualcomm® Neural Processing SDK.

The external python3 packages needed by this example are:

- numpy
- pandas
- sklearn
- tensorflow (1.6 or 1.11)

There are six files in $SNPE\_ROOT/examples/Models/word\_rnn folder

- inference.py
- input\_list.txt
- belling\_the\_cat.txt
- word\_rnn.py
- word\_rnn\_adb.sh
- NOTICE.txt

The **word\_rnn.py** python3 script creates and trains an RNN
model with one LSTM layer. After RNN training is done, the
corresponding frozen protobuf file will be generated.

The **inference.py** prompts the user to enter several words,
at which point **snpe-net-run** will be called in a loop to
generate subsequent words.

Prerequisites

- The Qualcomm® Neural Processing SDK has been set up following the [Qualcomm (R) Neural Processing SDK
Setup](https://docs.qualcomm.com/doc/80-63442-2/topic/setup.html) chapter.
- The [Tutorials Setup](https://docs.qualcomm.com/doc/80-63442-2/topic/tutorial_setup.html) has been
completed.
- TensorFlow is installed (see [TensorFlow
Setup](https://docs.qualcomm.com/doc/80-63442-2/topic/setup.html#tensorflow-setup))

Create, Train, and Convert Word-RNN Model

Run word\_rnn.py to create and train the Word-RNN model.

cd $SNPE_ROOT/examples/Models/word_rnn
    python3 word_rnn.py
    Copy to clipboard

The terminal will show the following messages.

Training will be logged in word_rnn_log.
    Load training file belling_the_cat.txt.
    Embedding created.
    Iter= 1000
    Iter= 2000
    Iter= 3000
    Iter= 4000
    Iter= 5000
    Optimization done.
    Converted 2 variables to const ops.
    Save frozen graph in word_rnn.pb.
    Copy to clipboard

Then, convert the frozen graph model with
snpe-tensorflow-to-dlc.

snpe-tensorflow-to-dlc --input_network word_rnn.pb \
                           --input_dim Placeholder "1, 4, 1" \
                           --out_node "rnn/lstm_cell/mul_11" \
                           --output_path word_rnn.dlc
    Copy to clipboard

After dlc conversion, we can view the converted dlc
architecture with **snpe-dlc-info** and **snpe-dlc-viewer** as
follows:

snpe-dlc-info -i word_rnn.dlc
    snpe-dlc-viewer -i word_rnn.dlc
    Copy to clipboard

Run on Linux Host

Go to the base location for the model and run the python3
script including **snpe-net-run**

python3 inference.py
    Copy to clipboard

After running **inference.py**, you will see a list of word
embedding keys and user input prompt as follows:

Load training file belling_the_cat.txt.
    Embedding created.
    Use host cpu.
    Display word embedding keys:
    dict_keys(['long', 'is', 'up', 'it', 'i', 'chief', 'our', 'procured', 'her', 'in', 'mouse', 'council', 'treacherous', 'meet', 'manner', 'approaches', 'with', 'propose', 'which', 'consider', 'thought', 'know', 'bell', 'signal', 'always', 'by', 'small', 'old', 'could', 'about', 'neck', 'of', 'approach', 'well', 'easy', 'take', 'all', 'outwit', 'met', 'they', 'this', 'who', 'cat', 'what', '.', 'will', 'attached', 'their', 'when', 'receive', 'agree', 'applause', 'and', 'if', 'now', 'to', 'a', 'round', 'enemy', 'was', 'ribbon', 'us', 'had', 'general', 'ago', 'means', 'last', 'venture', 'got', 'sly', 'measures', 'young', 'she', 'very', 'impossible', 'therefore', 'we', 'should', 'one', 'mice', 'case', '?', 'make', 'nobody', 'he', 'that', 'consists', 'spoke', 'from', 'easily', 'at', 'neighbourhood', 'the', 'looked', 'then', 'until', 'an', 'common', 'but', 'be', 'would', 'danger', 'retire', 'proposal', 'another', 'you', ',', 'while', 'escape', 'some', 'remedies', 'said'])
    Please input 4 words:
    Copy to clipboard

User can input embedded words and see the results. For example:
**long ago , the**

...
    ...
    -------------------------------------------------------------------------------
    Model String: N/A
    SNPE vX.Y.Z.dev
    -------------------------------------------------------------------------------
    Processing DNN input(s):
    ./input.raw
    -------------------------------------------------------------------------------
    Model String: N/A
    SNPE vX.Y.Z.dev
    -------------------------------------------------------------------------------
    Processing DNN input(s):
    ./input.raw
    Inference result: long ago , the said she a , , and the could could , , and the could could , , and the could could , , and the could could , , and the could
    Copy to clipboard

The **inference.py** will call **snpe-net-run** several times
to generate subsequent words with trained LSTM model.

**Binary data input**

Note that the Word-RNN model does not accept pure text files as
input. The model expects its input tensor dimension to be
**1x4x1** as a float array. The **create\_embedding** function
in **inference.py** will parse, collect, encode, and build the
word embedding. User inputs will then be transformed into a **1x4x1** vector
and sent into the LSTM model. Afterwards the LSTM output will
be also transformed into the corresponding embedded word.

Run on Target Platform ( Android/LE/UBUN )

**Select target architecture**

Qualcomm® Neural Processing SDK provides binaries for different target platforms.
Android binaries are  compiled with clang using libc++ STL implementation.
Below are examples for aarch64-android (Android platform)  and
aarch64-oe-linux-gcc11.2 toolchain (LE platform).
Similarly other toolchains for different platforms can be set as SNPE\_TARGET\_ARCH

# For Android targets: architecture: arm64-v8a - compiler: clang - STL: libc++
    export SNPE_TARGET_ARCH=aarch64-android
    
    # Example for LE targets
    export SNPE_TARGET_ARCH=aarch64-oe-linux-gcc11.2
    Copy to clipboard

For simplicity, this tutorial sets the target binaries to
aarch64-android.

**Push libraries and binaries to target**

Push Qualcomm® Neural Processing SDK libraries and the prebuilt snpe-net-run executable to
/data/local/tmp/snpeexample on the Android target. Set SNPE\_TARGET\_DSPARCH
to the DSP architecture of the target Android device.

export SNPE_TARGET_ARCH=aarch64-android
    export SNPE_TARGET_DSPARCH=hexagon-v73
    
    adb -s $DEVICE_ID shell "mkdir -p /data/local/tmp/snpeexample/$SNPE_TARGET_ARCH/bin"
    adb -s $DEVICE_ID shell "mkdir -p /data/local/tmp/snpeexample/$SNPE_TARGET_ARCH/lib"
    adb -s $DEVICE_ID shell "mkdir -p /data/local/tmp/snpeexample/dsp/lib"
    
    adb -s $DEVICE_ID push $SNPE_ROOT/lib/$SNPE_TARGET_ARCH/*.so \
          /data/local/tmp/snpeexample/$SNPE_TARGET_ARCH/lib
    adb -s $DEVICE_ID push $SNPE_ROOT/lib/$SNPE_TARGET_DSPARCH/unsigned/*.so \
          /data/local/tmp/snpeexample/dsp/lib
    adb -s $DEVICE_ID push $SNPE_ROOT/bin/$SNPE_TARGET_ARCH/snpe-net-run \
          /data/local/tmp/snpeexample/$SNPE_TARGET_ARCH/bin
    Copy to clipboard

**Set up enviroment variables**

Set up the library path, the path variable, and the target
architecture in adb shell to run the executable with the -h
argument to see its description.

adb -s $DEVICE_ID shell
    export SNPE_TARGET_ARCH=aarch64-android
    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp/snpeexample/$SNPE_TARGET_ARCH/lib
    export PATH=$PATH:/data/local/tmp/snpeexample/$SNPE_TARGET_ARCH/bin
    snpe-net-run -h
    exit
    Copy to clipboard

**Push model data to Android target**

To execute the Word-RNN model on your Android target follow these steps:

adb -s $DEVICE_ID shell "mkdir -p /data/local/tmp/word_rnn"
    adb -s $DEVICE_ID push input_list.txt /data/local/tmp/word_rnn
    adb -s $DEVICE_ID push input.raw /data/local/tmp/word_rnn
    adb -s $DEVICE_ID push word_rnn.dlc /data/local/tmp/word_rnn
    adb -s $DEVICE_ID push word_rnn_adb.sh /data/local/tmp/word_rnn
    Copy to clipboard

**Note:** It may take some time to push the word\_rnn dlc file to your target.

Running on Android using CPU Runtime

Run the Android C++ executable with the following commands:

cd /data/local/tmp/word_rnn
    snpe-net-run --container word_rnn.dlc --input_list input_list.txt
    Copy to clipboard

We will get the same result as when we [Run on Linux
Host](https://docs.qualcomm.com/doc/80-63442-2/topic/tutorial_word_rnn.html#run-on-linux-host).

Last Published: Oct 02, 2025

[Previous Topic
Running on Windows using DSP Runtime](https://docs.qualcomm.com/bundle/publicresource/80-63442-2/topics/tutorial_inceptionv3_win.md) [Next Topic
Running the Spoken Digit Recognition Model](https://docs.qualcomm.com/bundle/publicresource/80-63442-2/topics/tutorial_spoken_digit.md)