KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #ai-agents #developer-tools #typescript #codex #claude-code #mcp #rust #deepseek-harness #ai-agent #cli

gr-wavelearner

★ 62 Open GitHub ↗

Perform deep learning inference on signals

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# GR-WAVELEARNER
Incorporate Deep Learning into GNU Radio

### Author

<img src="https://deepwavedigital.com/media/images/dwd2_crop_transparent.png" Width="50%" />

This software is written by **Deepwave Digital, Inc.** [www.deepwavedigital.com]().

&nbsp;
### Inquiries
  - General company contact: [https://deepwavedigital.com/inquiry](https://deepwavedigital.com/inquiry/)

&nbsp;
### Description
This out of tree (OOT) module for GNU Radio contains code to provide an interface to call
[NVIDIA's TensorRT](https://developer.nvidia.com/tensorrt) deep learning binaries from a GNU Radio
flowgraph. TensorRT allows for deep learning networks to be optimized for inference operations on an
NVIDIA graphics processing units (GPU).

For an example of how to use GR-Wavelearner, see our presentation [here](http://deepwavedigital.com/media/2019/GR-Wavelearner_Overview.pdf).

&nbsp;
### Dependencies:     
  - **TensorRT** (v3.0+) [1]
    - **AIR-T** - The AIR-T already includes Tensor-RT so you may skip this section.
    - **NVIDIA Jetson** - If using the the NVIDIA Jetson, TensorRT is already included with
      Jetpack so you may skip this section.
      
    - **Computer with GPU card** -  you have two options for this dependency:
        1. Use the NVIDIA Docker - [TensorRT Release 18.08](https://docs.nvidia.com/deeplearning/sdk/tensorrt-container-release-notes/rel_18.08.html)
        2. Install TensorRT and its dependenices: CUDA and cuDNN. Most of the testing with this
           package has occured using the .deb packages (TensorRT 4.0 + CUDA 9.0). Any other method
           of installation may work but will require you make sure the software sees all the
           dependencies.  This software has been tested with the following packages (installed in this order):
            - [cuda-repo-ubuntu1604-9-0-local_9.0.176-1_amd64.deb](https://developer.nvidia.com/cuda-90-download-archive)
            - [libcudnn7-dev_7.3.1.20-1+cuda9.0_amd64.deb](https://developer.nvidia.com/rdp/cudnn-download)
            - [nv-tensorrt-repo-ubuntu1604-cuda9.0-ga-trt4.0.1.6-20180612_1-1_amd64.deb](https://developer.nvidia.com/nvidia-tensorrt-4x-download)
        
    - Both TensorRT and gr-wavelearner use C++14. As a result, the OOT modules are
            compiled with the C++14 standard flag set in CMake.

- **GNU Radio** (v3.7.9 or newer) [2]
    - This OOT module was tested with gnuradio-runtime, version 3.7.9 because that is the version
      available via
      
        `$ sudo apt install gnuradio`
  - **SWIG** (v3.0.8 or newer)
    - SWIG does not come with GNU Radio and may not be included with your Linux distribution.
    - Building this package will fail if SWIG is not  installed and you will get an import error
      for the inference block. The easiest way to install SWIG is:

`$ sudo apt install swig`      
  - **Doxygen** (Recommended, not required)
    - Installed via:
    
      `$ sudo apt install doxygen`

&nbsp;
### Requirments:
  - NVIDIA GPU that supports TensorRT v3.0 or newer or the NVIDIA Tegra TX2

&nbsp;
### Current Blocks
  - __**Inference**__ - This C++ block uses TensorRT to perform inference. It assumes one input
                        and one output node for the network. It requires a TensorRT PLAN file be
                        provided that contains information on what operations should take place.
                        The block currently does not handle complex data types. This is primarily
                        because the vast majority of deep learning software tools (if not all)
                        do not support complex operations yet. This does not mean that you cannot
                        perform deep learning on complex data, it just means that the neural
                        network will treat it as real. For example, one method is to associate
                        the in-phase and quadrature samples within the network's convolution
                        kernels [3].
                        
    **NOTE:** TensorRT plan files are platform specific. This means that a .plan file created on
              Jetson TX2 (like the one provided in `examples`) may not work on a GTX card. To
              ensure compatability, make sure you create your .plan file on the platform in which
              it will be executed.
  
  - __**Terminal Sink**__ - This Python block prints the output of a deep learning classifier
                            to the terminal for debugging and to help the user get up and running
                            quickly.
                            
  - __**cuFFT**__ - This C++ / CUDA block executes NVIDIA's cuFFT algorithm on an input data vector.

&nbsp;
## How to Build and Install gr-wavelearner on Ubuntu
1. Install Dependencies listed above (no seriously, make sure they are installed)
   - Make sure you can import gnuradio and tensorrt from the same python environment in which you are
     installing gr-wavelearner

2. Clone the gr-wavelearner repo
   ```
   $ git clone https://github.com/deepwavedigital/gr-wavelearner.git
   ```

3. This step may not be necessary if installing on the NVIDIA Jetson TX2.
   Check to make sure LD_LIBRARY_PATH and PATH environmental variables are properly set according to
   your CUDA install. This can typically be accomplished by placing the following at the end of your
   `.bashrc` file:
   ```
   # CUDA installation path
   export LD_LIBRARY_PATH=/usr/local/cuda-9.0/lib64:$LD_LIBRARY_PATH
   export PATH=/usr/local/cuda-9.0/bin:$PATH
   ```
   and then run:
   ```
   $ source ~/.bashrc
   ```

4. Install the OOT Module
   ```
   $ cd gr-wavelearner
   $ mkdir build
   $ cd build
   $ cmake ../
   $ make
   $ sudo make install
   $ sudo ldconfig
   ``` 
  
5. To uninstall gr-wavelearner Blocks from GNU Radio Companion
   ```
   cd gr-wavelearner/build
   sudo make uninstall
   ```

&nbsp;

&nbsp;
## Screen Shots
#### Example Flow Graph of Deep Learning Classifier

<img src="https://deepwavedigital.com/media/2019/classifier_test.png" Width="50%" />

&nbsp;
#### Inference Block

<img src="https://deepwavedigital.com/media/2019/inference_block.png" Width="25%" />

&nbsp;
#### Terminal Sink Block

<img src="https://deepwavedigital.com/media/2019/terminal_sink_block.png" Width="25%" />

&nbsp;
### General Workflow for Creating Applications
1. Train deep learning model (we suggest TensorFlow)
2. Export deep learning model to a UFF file
3. Using TensorRT, optimize the UFF file into a .plan engine file. Note that this stage must
   be performed on the system in which you are deploying your network. We provide an example
   of how to convert a UFF file to a PLAN file in `examples/uff2plan.py`.
4. Load .plan engine file into the `wavelearner.inference` block.
5. Update the `batch_size`, `input_length`, and `output_length` to match that of your deep
   learning model.

&nbsp;
### Troubleshooting
- The supported dependencies are listed in the table below. There is a good chance other versions
  will work with gr-wavelearner, but they have not been tested. We welcome any feedback on your
  successful builds.

| Software  | Versions Tested | Application Notes
| :---:     | :---:           | :---:               
| Ubuntu    | 16.04           | 
| Windows   | 10              | Tested with TensorRT 5.0
| Jetpack   | 3.0, 3.3        | 
| CUDA      | 9.0             |
| cuDNN     | 7.2, 7.3        |
| TensorRT  | 3.0, 4.0, 5.0   |

- If you are having trouble building gr-wavelearner, the first thing to check is the installed
  version of the NVIDIA dependencies.
    - Check installed version of **CUDA**:
      
      `$ nvcc -V`
      
      Should produce something like:
      ```
      nvcc: NVIDIA (R) Cuda compiler driverCopyright (c) 2005-2017 NVIDIA Corporation
      Built on Sun_Nov_19_03:10:15_CST_2017
      Cuda compilation tools, release 9.0, V9.0.252
      ````
      
      which would be **CUDA v9.0.252**.
    - Check installed version of **cuDNN**:
      
      `$ cat /usr/include/cudnn.h | grep "#define CUDNN_MAJOR" -A 2`
      
      Should produce something like:
      ```
      #define CUDNN_MAJOR 7
      #define CUDNN_MINOR 2
      #define CUDNN_PATCHLEVEL 1
      ```
      which would be **cuDNN v7.2.1**
      
    - Check installed version of **TensorRT**:
      
      `$ dpkg -l | grep TensorRT`
      
      Should produce something like:
      ```
      ii  graphsurgeon-tf        4.1.2-1+cuda9.0    amd64  GraphSurgeon for TensorRT package
      ii  libnvinfer-dev         4.1.2-1+cuda9.0    amd64  TensorRT development libraries and headers
      ii  libnvinfer-samples     4.1.2-1+cuda9.0    amd64  TensorRT samples and documentation
      ii  libnvinfer4            4.1.2-1+cuda9.0    amd64  TensorRT runtime libraries
      ii  python-libnvinfer      4.1.2-1+cuda9.0    amd64  Python bindings for TensorRT
      ii  python-libnvinfer-dev  4.1.2-1+cuda9.0    amd64  Python development package for TensorRT
      ii  python-libnvinfer-doc  4.1.2-1+cuda9.0    amd64  Documention and samples of python bindings for TensorRT
      ii  tensorrt               4.0.1.6-1+cuda9.0  amd64  Meta package of TensorRT
      ii  uff-converter-tf       4.1.2-1+cuda9.0    amd64  UFF converter for TensorRT package
      ```
      which would be **TensorRT v4.0.1.6** and **NVInfer v4.1.2**

&nbsp;
### Known Issues / Future Enhancements
- Currently the inference block's work() function only processes a single
   vector each time it is called. However, there may be more data available. It
   may improve performance to process all available data by either performing
   inference in a loop or (assuming the TensorRT engine has a large enough
   maximum batch size) combine the vectors into a larger batch.
- As of now, the input and output node dimensions are combined into a vector
   length. This makes the block easier to program; however, it may be more
   useful for the user to instead provide NCHW dimensions (i.e., to specify each
   dimension individually). Additionally, this would allow the engine validation
   step to check each dimension instead of combining everything into one vector
   length. For example, in the current code, if a 1x2x2048 node is expected,
   then the code will accept any shape (e.g., 4x64x16, 4096x1x1, 8x8x64, etc.)
   as long as the resulting dimensions combine into a vector length of 4096.
- Currently the inference block assumes one input node and one output node. As
   a result, networks with more than one input or output are not currently
   supported.
- The current block assumes that the GPU to be used for inference is device #0,
   which may not be correct for multiple GPU systems.
- As of now, only the device mapped memory API (aka. "zero copy" or UVA) is
   used since (in previous testing) this memory API provided the best
   performance on the Jetson TX2. Unified memory support should be considered
   since it would be fairly easy to add (very little code would change) and also
   improve performance for PCIe based cards.
- Performance metrics are always printed to the console. The user may want to
   log these instead or alternatively just ignore them completely.

&nbsp;
### Tags
Deep Learning, Artificial Intelligence, Machine Learning, TensorRT, GPU, Deepwave Digital, 
AIR-T, Jetson, NVIDIA, GNU Radio

&nbsp;
### Credits and License
GR-WAVELEARNER is designed and written by **Deepwave Digital, Inc.** [www.deepwavedigital.com]()
and is licensed under the GNU General Public License. Copyright notices at the top of source files.

&nbsp;
### References
[1] NVIDIA TensorRT - Programmable Inference Accelerator:
    [https://developer.nvidia.com/tensorrt]()

[2] GNU Radio - The Free & Open Software Radio Ecosystem:
    [https://www.gnuradio.org]()
    
[2] Making Sense of Signals Presentation- NVIDIA GPU Technology Conference:
    [http://on-demand.gputechconf.com/gtc/2018/video/S8375/]()

gr-wavelearner

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README