{"id":13586510,"url":"https://github.com/rapidsai/cusignal","last_synced_at":"2025-04-07T15:32:07.208Z","repository":{"id":36154907,"uuid":"203811620","full_name":"rapidsai/cusignal","owner":"rapidsai","description":"cuSignal - RAPIDS Signal Processing Library","archived":true,"fork":false,"pushed_at":"2023-09-21T18:53:21.000Z","size":14791,"stargazers_count":714,"open_issues_count":29,"forks_count":132,"subscribers_count":42,"default_branch":"branch-23.10","last_synced_at":"2024-11-06T04:39:44.784Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/rapidsai.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":"CITATION.cff","codeowners":".github/CODEOWNERS","security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2019-08-22T14:27:27.000Z","updated_at":"2024-11-02T17:23:10.000Z","dependencies_parsed_at":"2024-11-06T04:34:19.874Z","dependency_job_id":"92b201a9-ef6b-45d6-955e-2f016197f3bf","html_url":"https://github.com/rapidsai/cusignal","commit_stats":null,"previous_names":[],"tags_count":45,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rapidsai%2Fcusignal","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rapidsai%2Fcusignal/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rapidsai%2Fcusignal/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rapidsai%2Fcusignal/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/rapidsai","download_url":"https://codeload.github.com/rapidsai/cusignal/tar.gz/refs/heads/branch-23.10","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247679652,"owners_count":20978093,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-08-01T15:05:37.195Z","updated_at":"2025-04-07T15:32:06.551Z","avatar_url":"https://github.com/rapidsai.png","language":"Python","funding_links":[],"categories":["Python","GPU实用程序"],"sub_categories":[],"readme":"# \u003cdiv align=\"left\"\u003e\u003cimg src=\"https://rapids.ai/assets/images/rapids_logo.png\" width=\"90px\"/\u003e\u0026nbsp;cuSignal\u003c/div\u003e\n\n# Deprecation Notice\nRAPIDS v23.08 is the last formal release for cuSignal. Starting in 2019, cuSignal strived to provide a simple to use and highly performant library for signal processing developers working in Python. With over 400,000 total Anaconda downloads, we built an incredible community together. We are pleased to announce that much of the cuSignal codebase is moving to [CuPy](https://cupy.dev) and is highly aligned with CuPy's goal to GPU-accelerate the NumPy and SciPy ecosystems. By moving our work to CuPy, we allow developers to use a single library for signal processing (and more!) while also reducing software dependencies.\n\nTo continue your journey with GPUs, Python, and Signal Processing, please:\n- [Download CuPy](https://docs.cupy.dev/en/stable/install.html)\n- Visit `cupyx.scipy.signal` [source code](https://github.com/cupy/cupy/tree/main/cupyx/scipy/signal)\n- Read CuPy's `signal` module [documentation](https://docs.cupy.dev/en/latest/reference/scipy_signal.html)\n\nThe offical deprecation announcement can be found [here](https://docs.rapids.ai/notices/rsn0032/)\n\n***\n**cuSignal** is a GPU-accelerated signal processing library in Python that is both based on and extends the [SciPy Signal](https://github.com/scipy/scipy/tree/master/scipy/signal) API. Notably, cuSignal:\n- Delivers orders-of-magnitude speedups over CPU with a familiar API\n- Supports a zero-copy connection to popular Deep Learning frameworks like PyTorch, Tensorflow, and Jax\n- Runs on any CUDA-capable GPU of Maxwell architecture or newer, including the Jetson Nano\n- Optimizes streaming, real-time applications via zero-copy memory buffer between CPU and GPU\n- Is fully built within the GPU Python Ecosystem, where both core functionality and optimized kernels are dependent on the [CuPy](https://cupy.dev/) and [Numba](http://numba.pydata.org/) projects\n\nIf you're interested in the above concepts but prefer to program in C++ rather than Python, please consider [MatX](https://github.com/NVIDIA/MatX). MatX is an efficient C++17 GPU Numerical Computing library with a Pythonic Syntax.\n\n\n## Table of Contents\n* [Quick Start](#quick-start)\n* [Installation](#installation)\n    * [Conda: Linux OS](#conda-linux-os-preferred)\n    * [Source: aarch64 (Jetson Nano, TK1, TX2, Xavier), Linux OS](#source-aarch64-jetson-nano-tk1-tx2-xavier-agx-clara-devkit-linux-os)\n    * [Source: Linux OS](#source-linux-os)\n    * [Source: Windows OS (with CUDA on WSL)](#source-windows-os)\n    * [Docker](#docker---all-rapids-libraries-including-cusignal)\n* [Documentation](#documentation)\n* [Notebooks and Examples](#notebooks-and-examples)\n* [Software Defined Radio (SDR) Integration](#sdr-integration)\n* [Benchmarking](#benchmarking)\n* [Contribution Guide](#contributing-guide)\n* [cuSignal Blogs and Talks](#cusignal-blogs-and-talks)\n\n\n## Quick Start\nA polyphase resampler changes the sample rate of an incoming signal while using polyphase filter banks to preserve the overall shape of the original signal. The following example shows how cuSignal serves as a drop-in replacement for SciPy Signal's [polyphase resampler](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.resample_poly.html) and how cuSignal interacts with data generated on GPU with CuPy, a drop-in replacement for the numerical computing library [NumPy](https://numpy.org/).\n\n**Scipy Signal and NumPy (CPU)**\n```python\nimport numpy as np\nfrom scipy import signal\n\nstart = 0\nstop = 10\nnum_samps = int(1e8)\nresample_up = 2\nresample_down = 3\n\ncx = np.linspace(start, stop, num_samps, endpoint=False)\ncy = np.cos(-cx**2/6.0)\n\n%%timeit\ncf = signal.resample_poly(cy, resample_up, resample_down, window=('kaiser', 0.5))\n```\nThis code executes on 2x Xeon E5-2600 in 2.36 sec.\n\n**cuSignal and CuPy (GPU)**\n```python\nimport cupy as cp\nimport cusignal\n\nstart = 0\nstop = 10\nnum_samps = int(1e8)\nresample_up = 2\nresample_down = 3\n\ngx = cp.linspace(start, stop, num_samps, endpoint=False)\ngy = cp.cos(-gx**2/6.0)\n\n%%timeit\ngf = cusignal.resample_poly(gy, resample_up, resample_down, window=('kaiser', 0.5))\n```\nThis code executes on an NVIDIA V100 in 13.8 ms, a 170x increase over SciPy Signal. On an A100, this same code completes in 4.69 ms; 500x faster than CPU.\n\nNext, we'll show that cuSignal can be used to access data that isn't explicitly generated on GPU. In this case, we use `cusignal.get_shared_mem` to allocate a buffer of memory that's been addressed by both the GPU and CPU. This process allows cuSignal to process data _online_.\n\n**cuSignal with Data Generated on the CPU with Mapped, Pinned (zero-copy) Memory**\n```python\nimport cupy as cp\nimport numpy as np\nimport cusignal\n\nstart = 0\nstop = 10\nnum_samps = int(1e8)\nresample_up = 2\nresample_down = 3\n\n# Generate Data on CPU with NumPy\ncx = np.linspace(start, stop, num_samps, endpoint=False)\ncy = np.cos(-cx**2/6.0)\n\n# Create shared memory between CPU and GPU and load with CPU signal (cy)\ngpu_signal = cusignal.get_shared_mem(num_samps, dtype=np.float64)\n\n%%time\n# Move data to GPU/CPU shared buffer and run polyphase resampler\ngpu_signal[:] = cy\ngf = cusignal.resample_poly(gpu_signal, resample_up, resample_down, window=('kaiser', 0.5))\n```\nThis code executes on an NVIDIA V100 in 174 ms.\n\nFinally, the example below shows that cuSignal can access data that's been generated elsewhere and moved to the GPU via `cp.asarray`. While this approach is fine for prototyping and algorithm development, it should be avoided for online signal processing.\n\n**cuSignal with Data Generated on the CPU and Copied to GPU**\n```python\nimport cupy as cp\nimport numpy as np\nimport cusignal\n\nstart = 0\nstop = 10\nnum_samps = int(1e8)\nresample_up = 2\nresample_down = 3\n\n# Generate Data on CPU\ncx = np.linspace(start, stop, num_samps, endpoint=False)\ncy = np.cos(-cx**2/6.0)\n\n%%time\ngf = cusignal.resample_poly(cp.asarray(cy), resample_up, resample_down, window=('kaiser', 0.5))\n```\nThis code executes on an NVIDIA V100 in 637 ms.\n\n\n### Installation\ncuSignal has been tested on and supports all modern GPUs - from Maxwell to Ampere. While Anaconda is the preferred installation mechanism for cuSignal, developers and Jetson users should follow the source build instructions below; there isn't presently a conda aarch64 package for cuSignal.\n\n### Conda, Linux OS (Preferred)\ncuSignal can be installed with ([Miniconda](https://docs.conda.io/en/latest/miniconda.html) or the full [Anaconda distribution](https://www.anaconda.com/distribution/)) from the `rapidsai` channel. If you're using a Jetson GPU, please follow the build instructions [below](https://github.com/rapidsai/cusignal#conda---jetson-nano-tk1-tx2-xavier-linux-os)\n\n\n```\nconda install -c rapidsai -c conda-forge -c nvidia \\\n    cusignal\n\n# To specify a certain CUDA or Python version (e.g. 11.8 and 3.9, respectively)\nconda install -c rapidsai -c conda-forge -c nvidia \\\n    cusignal python=3.9 cudatoolkit=11.8\n```\n\nFor the nightly verison of `cusignal`, which includes pre-release features:\n\n```\nconda install -c rapidsai-nightly -c conda-forge -c nvidia \\\n    cusignal\n\n# To specify a certain CUDA or Python version (e.g. 11.8 and 3.9, respectively)\nconda install -c rapidsai-nightly -c conda-forge -c nvidia \\\n    cusignal python=3.9 cudatoolkit=11.8\n```\n\nWhile only CUDA versions \u003e= 11.2 are officially supported, cuSignal has been confirmed to work with CUDA version 10.2 and above. If you run into any issues with the conda install, please follow the source installation instructions, below.\n\nFor more OS and version information, please visit the [RAPIDS version picker](https://rapids.ai/start.html).\n\n\n### Source, aarch64 (Jetson Nano, TK1, TX2, Xavier, AGX Clara DevKit), Linux OS\n\nSince the Jetson platform is based on the arm chipset, we need to use an aarch64 supported Anaconda environment. While there are multiple options here, we recommend [miniforge](https://github.com/conda-forge/miniforge). Further, it's assumed that your Jetson device is running a current (\u003e= 4.3) edition of [JetPack](https://developer.nvidia.com/embedded/jetpack) and contains the CUDA Toolkit.\n\nPlease note, prior to installing cuSignal, ensure that your PATH environment variables are set to find the CUDA Toolkit. This can be done with:\n```bash\nexport PATH=/usr/local/cuda/bin${PATH:+:${PATH}}\nexport LD_LIBRARY_PATH=/usr/local/cuda/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}\n```\n\n1. Clone the cuSignal repository\n\n    ```bash\n    # Set the location to cuSignal in an environment variable CUSIGNAL_HOME\n    export CUSIGNAL_HOME=$(pwd)/cusignal\n\n    # Download the cuSignal repo\n    git clone https://github.com/rapidsai/cusignal.git $CUSIGNAL_HOME\n    ```\n\n2. Install [miniforge](https://github.com/conda-forge/miniforge) and create the cuSignal conda environment:\n\n    ```bash\n    cd $CUSIGNAL_HOME\n    conda env create -f conda/environments/cusignal_jetson_base.yml\n    ```\n\n    Note: Compilation and installation of CuPy can be quite lengthy (~30+ mins), particularly on the Jetson Nano. Please consider setting the `CUPY_NVCC_GENERATE_CODE` environment variable to decrease the CuPy dependency install time:\n\n    ```bash\n    export CUPY_NVCC_GENERATE_CODE=\"arch=compute_XX,code=sm_XX\"\n    ```\n\n    where `XX` is your GPU's [compute capability](https://developer.nvidia.com/cuda-gpus#compute). If you'd like to compile to multiple architectures (e.g Nano and Xavier), concatenate the `arch=...` string with semicolins.\n\n3. Activate created conda environment\n\n    `conda activate cusignal-dev`\n\n4. Install cuSignal module\n\n    ```bash\n    cd $CUSIGNAL_HOME\n    ./build.sh  # install cuSignal to $PREFIX if set, otherwise $CONDA_PREFIX\n                # run ./build.sh -h to print the supported command line options.\n    ```\n\n5. Once installed, periodically update environment\n\n    ```bash\n    cd $CUSIGNAL_HOME\n    conda env update -f conda/environments/cusignal_jetson_base.yml\n    ```\n\n6. Optional: Confirm unit testing via PyTest\n\n    ```bash\n    cd $CUSIGNAL_HOME/python\n    pytest -v  # for verbose mode\n    pytest -v -k \u003cfunction name\u003e  # for more select testing\n    ```\n\n\n### Source, Linux OS\n\n1. Clone the cuSignal repository\n\n    ```bash\n    # Set the location to cuSignal in an environment variable CUSIGNAL_HOME\n    export CUSIGNAL_HOME=$(pwd)/cusignal\n\n    # Download the cuSignal repo\n    git clone https://github.com/rapidsai/cusignal.git $CUSIGNAL_HOME\n    ```\n\n2. Download and install [Anaconda](https://www.anaconda.com/distribution/) or [Miniconda](https://docs.conda.io/en/latest/miniconda.html) then create the cuSignal conda environment:\n\n    **Base environment (core dependencies for cuSignal)**\n\n    ```bash\n    cd $CUSIGNAL_HOME\n    conda env create -f conda/environments/cusignal_base.yml\n    ```\n\n    **Full environment (including RAPIDS's cuDF, cuML, cuGraph, and PyTorch)**\n\n    ```bash\n    cd $CUSIGNAL_HOME\n    conda env create -f conda/environments/cusignal_full.yml\n    ```\n\n3. Activate created conda environment\n\n    `conda activate cusignal-dev`\n\n4. Install cuSignal module\n\n    ```bash\n    cd $CUSIGNAL_HOME\n    ./build.sh  # install cuSignal to $PREFIX if set, otherwise $CONDA_PREFIX\n                # run ./build.sh -h to print the supported command line options.\n    ```\n\n5. Once installed, periodically update environment\n\n    ```bash\n    cd $CUSIGNAL_HOME\n    conda env update -f conda/environments/cusignal_base.yml\n    ```\n\n6. Optional: Confirm unit testing via PyTest\n\n    ```bash\n    cd $CUSIGNAL_HOME/python\n    pytest -v  # for verbose mode\n    pytest -v -k \u003cfunction name\u003e  # for more select testing\n    ```\n\n\n### Source, Windows OS\n\nWe have confirmed that cuSignal successfully builds and runs on Windows by using [CUDA on WSL](https://docs.nvidia.com/cuda/wsl-user-guide/index.html). Please follow the instructions in the link to install WSL 2 and the associated CUDA drivers. You can then proceed to follow the cuSignal source build instructions, below.\n\n1. Download and install [Anaconda](https://www.anaconda.com/distribution/) for Windows. In an Anaconda Prompt, navigate to your checkout of cuSignal.\n\n2. Create cuSignal conda environment\n\n    `conda create --name cusignal-dev`\n\n3. Activate conda environment\n\n    `conda activate cusignal-dev`\n\n4. Install cuSignal Core Dependencies\n\n    ```\n    conda install numpy numba scipy cudatoolkit pip\n    pip install cupy-cudaXXX\n    ```\n\n    Where XXX is the version of the CUDA toolkit you have installed. 11.5, for example is `cupy-cuda115`. See the [CuPy Documentation](https://docs-cupy.chainer.org/en/stable/install.html#install-cupy) for information on getting wheels for other versions of CUDA.\n\n5. Install cuSignal module\n\n    ```\n    ./build.sh\n    ```\n\n6. Optional: Confirm unit testing via PyTest\n    In the cuSignal top level directory:\n    ```\n    pip install pytest pytest-benchmark\n    pytest\n    ```\n\n\n### Docker - All RAPIDS Libraries, including cuSignal\n\ncuSignal is part of the general RAPIDS docker container but can also be built using the included Dockerfile and the below instructions to build and run the container. Please note, `\u003cimage\u003e` and `\u003ctag\u003e` are user specified, for example `docker build -t cusignal:cusignal-22.12 docker/.`.\n\n```\ndocker build -t \u003cimage\u003e:\u003ctag\u003e docker/.\ndocker run --gpus all --rm -it \u003cimage\u003e:\u003ctag\u003e /bin/bash\n```\n\nPlease see the [RAPIDS Release Selector](https://rapids.ai/start.html) for more information on supported Python, Linux, and CUDA versions and for the specific command to pull the generic RAPIDS container.\n\n\n## Documentation\nThe complete cuSignal API documentation including a complete list of functionality and examples can be found for both the Stable and Nightly (Experimental) releases. cuSignal has about 75% coverage of the SciPy Signal API and includes added functionality, particularly for phased array systems and speech analysis. Please search the documentation for your function of interest and [file an issue](https://github.com/rapidsai/cusignal/issues/new/choose) if you see a gap.\n\n[cuSignal (Stable)](https://docs.rapids.ai/api/cusignal/stable/) | [cuSignal (Nightly)](https://docs.rapids.ai/api/cusignal/nightly/)\n\n\n## Notebooks and Examples\ncuSignal strives for 100% coverage between features and notebook examples. While we stress GPU performance, our guiding phisolophy is based on user productivity, and it's always such a bummer when you can't quickly figure out how to use exciting new features.\n\nCore API examples are shown in the `api_guide` of our [Notebooks folder](https://github.com/rapidsai/cusignal/blob/main/notebooks). We also provide some example online and offline streaming software-defined radio examples in the `srd` part of the [Notebooks](https://github.com/rapidsai/cusignal/blob/main/notebooks/sdr). See [SDR Integration](#sdr-integration) for more information, too.\n\nIn addition to learning about how the API works, these notebooks provide rough benchmarking metrics for user-defined parameters like window length, signal size, and datatype.\n\n\n## SDR Integration\n[SoapySDR](https://github.com/pothosware/SoapySDR/wiki) is a \"vendor neutral and platform independent\" library for software-defined radio usage. When used in conjunction with device (SDR) specific modules, SoapySDR allows for easy command-and-control of radios from Python or C++. To install SoapySDR into an existing cuSignal Conda environment, run:\n\n`conda install -c conda-forge soapysdr`\n\nA full list of subsequent modules, specific to your SDR are listed [here](https://anaconda.org/search?q=soapysdr), but some common ones:\n- rtlsdr: `conda install -c conda-forge soapysdr-module-rtlsdr`\n- Pluto SDR: `conda install -c conda-forge soapysdr-module-plutosdr`\n- UHD: `conda install -c conda-forge soapysdr-module-uhd`\n\nAnother popular SDR library, specific to the rtl-sdr, is [pyrtlsdr](https://github.com/roger-/pyrtlsdr).\n\nFor examples using SoapySDR, pyrtlsdr, and cuSignal, please see the [notebooks/sdr](https://github.com/rapidsai/cusignal/blob/main/notebooks/sdr) directory.\n\nPlease note, for most rtlsdr devices, you'll need to blacklist the libdvb driver in Linux. To do this, run `sudo vi /etc/modprobe.d/blacklist.conf` and add `blacklist dvb_usb_rtl28xxu` to the end of the file. Restart your computer upon completion.\n\nIf you have a SDR that isn't listed above (like the LimeSDR), don't worry! You can symbolically link the system-wide Python bindings installed via `apt-get` to the local conda environment. Further, check conda-forge for any packages before installing something from source. Please file an issue if you run into any problems.\n\n\n## Benchmarking\ncuSignal uses pytest-benchmark to compare performance between CPU and GPU signal processing implementations. To run cuSignal's benchmark suite, **navigate to the topmost python directory ($CUSIGNAL_HOME/python)** and run:\n\n`pytest --benchmark-enable --benchmark-gpu-disable`\n\nBenchmarks are disabled by default in `setup.cfg` providing only test correctness checks.\n\nAs with the standard pytest tool, the user can use the `-v` and `-k` flags for verbose mode and to select a specific benchmark to run. When intrepreting the output, we recommend comparing the _mean_ execution time reported.\n\nTo reduce columns in benchmark result's table, add `--benchmark-columns=LABELS`, like `--benchmark-columns=min,max,mean`.\nFor more information on `pytest-benchmark` please visit the [Usage Guide](https://pytest-benchmark.readthedocs.io/en/latest/usage.html).\n\nParameter `--benchmark-gpu-disable` is to disable memory checks from [Rapids GPU benchmark tool](https://github.com/rapidsai/benchmark).\nDoing so speeds up benchmarking.\n\nIf you wish to skip benchmarks of SciPy functions add `-m \"not cpu\"`\n\nLastly, benchmarks will be executed on local files. Therefore to test recent changes made to source, rebuild cuSignal.\n\n### Example\n`pytest -k upfirdn2d -m \"not cpu\" --benchmark-enable --benchmark-gpu-disable --benchmark-columns=mean`\n\n### Output\n```bash\ncusignal/test/test_filtering.py ..................                                                                                                                                                                                                                                   [100%]\n\n\n---------- benchmark 'UpFirDn2d': 18 tests -----------\nName (time in us, mem in bytes)         Mean\n------------------------------------------------------\ntest_upfirdn2d_gpu[-1-1-3-256]      195.2299 (1.0)\ntest_upfirdn2d_gpu[-1-9-3-256]      196.1766 (1.00)\ntest_upfirdn2d_gpu[-1-1-7-256]      196.2881 (1.01)\ntest_upfirdn2d_gpu[0-2-3-256]       196.9984 (1.01)\ntest_upfirdn2d_gpu[0-9-3-256]       197.5675 (1.01)\ntest_upfirdn2d_gpu[0-1-7-256]       197.9015 (1.01)\ntest_upfirdn2d_gpu[-1-9-7-256]      198.0923 (1.01)\ntest_upfirdn2d_gpu[-1-2-7-256]      198.3325 (1.02)\ntest_upfirdn2d_gpu[0-2-7-256]       198.4676 (1.02)\ntest_upfirdn2d_gpu[0-9-7-256]       198.6437 (1.02)\ntest_upfirdn2d_gpu[0-1-3-256]       198.7477 (1.02)\ntest_upfirdn2d_gpu[-1-2-3-256]      200.1589 (1.03)\ntest_upfirdn2d_gpu[-1-2-2-256]      213.0316 (1.09)\ntest_upfirdn2d_gpu[0-1-2-256]       213.0944 (1.09)\ntest_upfirdn2d_gpu[-1-9-2-256]      214.6168 (1.10)\ntest_upfirdn2d_gpu[0-2-2-256]       214.6975 (1.10)\ntest_upfirdn2d_gpu[-1-1-2-256]      216.4033 (1.11)\ntest_upfirdn2d_gpu[0-9-2-256]       217.1675 (1.11)\n------------------------------------------------------\n```\n\n\n## Contributing Guide\n\nReview the [CONTRIBUTING.md](https://github.com/rapidsai/cusignal/blob/main/CONTRIBUTING.md) file for information on how to contribute code and issues to the project. The TL;DR, as applicable to cuSignal, is to fork our repository to your own project space, implement a feature, and submit a PR against cuSignal's `main` branch from your fork.\n\nIf you notice something broken with cuSignal or have a feature request -- whether for a new function to be added or for additional performance, please [file an issue](https://github.com/rapidsai/cusignal/issues/new/choose). We love to hear feedback, whether positive or negative.\n\n\n## cuSignal Blogs and Talks\n* cuSignal - GPU Accelerating SciPy Signal with Numba and CuPy cuSignal - SciPy 2020 - [Recording](https://youtu.be/yYlX2bbdXDk)\n* Announcement Talk - GTC DC 2019 - [Recording](https://on-demand.gputechconf.com/gtcdc/2019/video/dc91165-cusignal-gpu-acceleration-of-scipy-signal/) | [Slides](https://on-demand.gputechconf.com/gtcdc/2019/pdf/dc91165-cusignal-gpu-acceleration-of-scipy-signal.pdf)\n* [GPU Accelerated Signal Processing with cuSignal](https://medium.com/rapids-ai/gpu-accelerated-signal-processing-with-cusignal-689062a6af8) - Adam Thompson - Medium\n* [cuSignal 0.13 - Entering the Big Leagues and Focused on Screamin' Streaming Performance](https://medium.com/rapids-ai/cusignal-0-13-entering-the-big-leagues-and-focused-on-screamin-streaming-performance-141908b10b3b) - Adam Thompson - Medium\n* [cuSignal: Easy CUDA GPU Acceleration for SDR DSP and Other Applications](https://www.rtl-sdr.com/cusignal-easy-cuda-gpu-acceleration-for-sdr-dsp-and-other-applications/) - RTL-SDR.com\n* [cuSignal on the AIR-T](http://docs.deepwavedigital.com/Tutorials/7_cuSignal.html) - Deepwave Digital\n* [Detecting, Labeling, and Recording Training Data with the AIR-T and cuSignal](https://www.youtube.com/watch?v=yhVm9hH4nIo) - Deepwave Digital\n* [Signal Processing and Deep Learning](https://www.youtube.com/watch?v=S17vUaTDHts) - Deepwave Digital\n* [cuSignal and CyberRadio Demonstrate GPU Accelerated SDR](https://limemicro.com/news/cusignal-and-cyberradio-demonstrate-gpu-accelerated-sdr/) - Andrew Back - LimeMicro\n* [cuSignal IEEE ICASSP 2021 Tutorial](https://github.com/awthomp/cusignal-icassp-tutorial)\n* [Follow the latest cuSignal Announcements on Twitter](https://twitter.com/hashtag/cusignal?f=live)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frapidsai%2Fcusignal","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Frapidsai%2Fcusignal","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frapidsai%2Fcusignal/lists"}