From 8c93d7c3917274d2020ca948147a1aa8ef8ba078 Mon Sep 17 00:00:00 2001 From: TorchDSP <108295102+TorchDSP@users.noreply.github.com> Date: Tue, 22 Nov 2022 09:20:43 -0500 Subject: [PATCH] Wideband datasets, models, etc. (#21) * Wideband extensions to TorchSig * add missing req and update dataset init * Adding necessary transforms and visualizations. Co-authored-by: Luke Boegner Co-authored-by: Garrett Vanhoy --- .gitignore | 3 + README.md | 11 +- docs/datasets.rst | 30 + docs/models.rst | 84 +- docs/transforms.rst | 49 + docs/utils.rst | 14 +- .../03_example_widebandsig53_dataset.ipynb | 469 ++++++ ...example_wideband_modulations_dataset.ipynb | 192 +++ examples/05_example_wideband_detector.ipynb | 635 ++++++++ requirements.txt | 2 + setup.py | 21 +- torchsig/__init__.py | 1 + torchsig/datasets/__init__.py | 5 +- torchsig/datasets/conf.py | 42 +- torchsig/datasets/file_datasets.py | 802 ++++++++++ torchsig/datasets/synthetic.py | 318 +++- torchsig/datasets/wideband.py | 1241 +++++++++++++++ torchsig/datasets/wideband_sig53.py | 204 +++ torchsig/models/__init__.py | 6 +- torchsig/models/iq_models/__init__.py | 4 + .../models/iq_models/efficientnet/LICENSE.md | 201 +++ .../models/iq_models/efficientnet/README.md | 5 + .../models/iq_models/efficientnet/__init__.py | 1 + .../efficientnet}/efficientnet.py | 0 torchsig/models/iq_models/xcit/LICENSE.md | 201 +++ torchsig/models/iq_models/xcit/README.md | 5 + torchsig/models/iq_models/xcit/__init__.py | 1 + torchsig/models/{ => iq_models/xcit}/xcit.py | 0 .../models/spectrogram_models/__init__.py | 8 + .../models/spectrogram_models/detr/LICENSE.md | 201 +++ .../models/spectrogram_models/detr/README.md | 5 + .../spectrogram_models/detr/__init__.py | 1 + .../models/spectrogram_models/detr/detr.py | 300 ++++ .../models/spectrogram_models/detr/modules.py | 494 ++++++ .../models/spectrogram_models/detr/utils.py | 195 +++ .../mask2former/LICENSE_Detectron2.md | 202 +++ .../mask2former/LICENSE_Mask2Former.md | 19 + .../spectrogram_models/mask2former/README.md | 5 + .../mask2former/__init__.py | 1 + .../mask2former/backbone.py | 38 + .../mask2former/criterion.py | 583 ++++++++ .../mask2former/mask2former.py | 258 ++++ .../spectrogram_models/mask2former/modules.py | 146 ++ .../mask2former/ops/functions/__init__.py | 13 + .../ops/functions/ms_deform_attn_func.py | 72 + .../mask2former/ops/make.sh | 13 + .../mask2former/ops/modules/__init__.py | 12 + .../mask2former/ops/modules/ms_deform_attn.py | 125 ++ .../mask2former/ops/setup.py | 78 + .../ops/src/cpu/ms_deform_attn_cpu.cpp | 46 + .../ops/src/cpu/ms_deform_attn_cpu.h | 38 + .../ops/src/cuda/ms_deform_attn_cuda.cu | 158 ++ .../ops/src/cuda/ms_deform_attn_cuda.h | 35 + .../ops/src/cuda/ms_deform_im2col_cuda.cuh | 1332 +++++++++++++++++ .../mask2former/ops/src/ms_deform_attn.h | 67 + .../mask2former/ops/src/vision.cpp | 21 + .../mask2former/ops/test.py | 92 ++ .../mask2former/pixel_decoder.py | 724 +++++++++ .../mask2former/predictor.py | 395 +++++ .../spectrogram_models/mask2former/utils.py | 298 ++++ .../spectrogram_models/pspnet/LICENSE.md | 21 + .../spectrogram_models/pspnet/README.md | 5 + .../spectrogram_models/pspnet/__init__.py | 1 + .../spectrogram_models/pspnet/modules.py | 54 + .../spectrogram_models/pspnet/pspnet.py | 281 ++++ .../models/spectrogram_models/pspnet/utils.py | 140 ++ .../spectrogram_models/yolov5/LICENSE.md | 674 +++++++++ .../spectrogram_models/yolov5/README.md | 5 + .../spectrogram_models/yolov5/__init__.py | 1 + .../spectrogram_models/yolov5/mean_ap.py | 802 ++++++++++ .../spectrogram_models/yolov5/modules.py | 804 ++++++++++ .../models/spectrogram_models/yolov5/utils.py | 343 +++++ .../spectrogram_models/yolov5/yolov5.py | 247 +++ .../spectrogram_models/yolov5/yolov5f.yaml | 50 + .../spectrogram_models/yolov5/yolov5l.yaml | 48 + .../spectrogram_models/yolov5/yolov5m.yaml | 48 + .../spectrogram_models/yolov5/yolov5n.yaml | 48 + .../spectrogram_models/yolov5/yolov5p.yaml | 50 + .../spectrogram_models/yolov5/yolov5s.yaml | 48 + .../spectrogram_models/yolov5/yolov5x.yaml | 48 + torchsig/transforms/__init__.py | 2 + .../deep_learning_techniques/__init__.py | 2 +- .../deep_learning_techniques/dlt.py | 455 +++++- .../deep_learning_techniques/functional.py | 102 ++ .../transforms/expert_feature/__init__.py | 2 +- torchsig/transforms/expert_feature/eft.py | 8 +- .../transforms/expert_feature/functional.py | 201 +++ torchsig/transforms/functional.py | 30 +- .../transforms/signal_processing/__init__.py | 2 +- .../signal_processing/functional.py | 92 ++ torchsig/transforms/signal_processing/sp.py | 2 +- .../spectrogram_transforms/__init__.py | 2 + .../spectrogram_transforms/functional.py | 168 +++ .../transforms/spectrogram_transforms/spec.py | 744 +++++++++ .../transforms/system_impairment/__init__.py | 2 +- .../system_impairment/functional.py | 635 ++++++++ torchsig/transforms/system_impairment/si.py | 196 ++- .../target_transforms/target_transforms.py | 974 +++++++++++- torchsig/transforms/transforms.py | 30 + .../transforms/wireless_channel/__init__.py | 2 +- .../transforms/wireless_channel/functional.py | 163 ++ torchsig/transforms/wireless_channel/wce.py | 34 +- torchsig/utils/visualize.py | 431 +++++- torchsig/version.py | 1 + 104 files changed, 18329 insertions(+), 191 deletions(-) create mode 100644 .gitignore create mode 100644 examples/03_example_widebandsig53_dataset.ipynb create mode 100644 examples/04_example_wideband_modulations_dataset.ipynb create mode 100644 examples/05_example_wideband_detector.ipynb create mode 100644 torchsig/datasets/file_datasets.py create mode 100644 torchsig/datasets/wideband.py create mode 100644 torchsig/datasets/wideband_sig53.py create mode 100644 torchsig/models/iq_models/__init__.py create mode 100644 torchsig/models/iq_models/efficientnet/LICENSE.md create mode 100644 torchsig/models/iq_models/efficientnet/README.md create mode 100644 torchsig/models/iq_models/efficientnet/__init__.py rename torchsig/models/{ => iq_models/efficientnet}/efficientnet.py (100%) create mode 100644 torchsig/models/iq_models/xcit/LICENSE.md create mode 100644 torchsig/models/iq_models/xcit/README.md create mode 100644 torchsig/models/iq_models/xcit/__init__.py rename torchsig/models/{ => iq_models/xcit}/xcit.py (100%) create mode 100644 torchsig/models/spectrogram_models/__init__.py create mode 100644 torchsig/models/spectrogram_models/detr/LICENSE.md create mode 100644 torchsig/models/spectrogram_models/detr/README.md create mode 100644 torchsig/models/spectrogram_models/detr/__init__.py create mode 100644 torchsig/models/spectrogram_models/detr/detr.py create mode 100644 torchsig/models/spectrogram_models/detr/modules.py create mode 100644 torchsig/models/spectrogram_models/detr/utils.py create mode 100644 torchsig/models/spectrogram_models/mask2former/LICENSE_Detectron2.md create mode 100644 torchsig/models/spectrogram_models/mask2former/LICENSE_Mask2Former.md create mode 100644 torchsig/models/spectrogram_models/mask2former/README.md create mode 100644 torchsig/models/spectrogram_models/mask2former/__init__.py create mode 100644 torchsig/models/spectrogram_models/mask2former/backbone.py create mode 100644 torchsig/models/spectrogram_models/mask2former/criterion.py create mode 100644 torchsig/models/spectrogram_models/mask2former/mask2former.py create mode 100644 torchsig/models/spectrogram_models/mask2former/modules.py create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/functions/__init__.py create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/functions/ms_deform_attn_func.py create mode 100755 torchsig/models/spectrogram_models/mask2former/ops/make.sh create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/modules/__init__.py create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/modules/ms_deform_attn.py create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/setup.py create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/src/cpu/ms_deform_attn_cpu.cpp create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/src/cpu/ms_deform_attn_cpu.h create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_attn_cuda.cu create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_attn_cuda.h create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_im2col_cuda.cuh create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/src/ms_deform_attn.h create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/src/vision.cpp create mode 100644 torchsig/models/spectrogram_models/mask2former/ops/test.py create mode 100644 torchsig/models/spectrogram_models/mask2former/pixel_decoder.py create mode 100644 torchsig/models/spectrogram_models/mask2former/predictor.py create mode 100644 torchsig/models/spectrogram_models/mask2former/utils.py create mode 100644 torchsig/models/spectrogram_models/pspnet/LICENSE.md create mode 100644 torchsig/models/spectrogram_models/pspnet/README.md create mode 100644 torchsig/models/spectrogram_models/pspnet/__init__.py create mode 100644 torchsig/models/spectrogram_models/pspnet/modules.py create mode 100644 torchsig/models/spectrogram_models/pspnet/pspnet.py create mode 100644 torchsig/models/spectrogram_models/pspnet/utils.py create mode 100644 torchsig/models/spectrogram_models/yolov5/LICENSE.md create mode 100644 torchsig/models/spectrogram_models/yolov5/README.md create mode 100644 torchsig/models/spectrogram_models/yolov5/__init__.py create mode 100644 torchsig/models/spectrogram_models/yolov5/mean_ap.py create mode 100644 torchsig/models/spectrogram_models/yolov5/modules.py create mode 100644 torchsig/models/spectrogram_models/yolov5/utils.py create mode 100644 torchsig/models/spectrogram_models/yolov5/yolov5.py create mode 100644 torchsig/models/spectrogram_models/yolov5/yolov5f.yaml create mode 100644 torchsig/models/spectrogram_models/yolov5/yolov5l.yaml create mode 100644 torchsig/models/spectrogram_models/yolov5/yolov5m.yaml create mode 100644 torchsig/models/spectrogram_models/yolov5/yolov5n.yaml create mode 100644 torchsig/models/spectrogram_models/yolov5/yolov5p.yaml create mode 100644 torchsig/models/spectrogram_models/yolov5/yolov5s.yaml create mode 100644 torchsig/models/spectrogram_models/yolov5/yolov5x.yaml create mode 100644 torchsig/transforms/deep_learning_techniques/functional.py create mode 100644 torchsig/transforms/expert_feature/functional.py create mode 100644 torchsig/transforms/signal_processing/functional.py create mode 100644 torchsig/transforms/spectrogram_transforms/__init__.py create mode 100644 torchsig/transforms/spectrogram_transforms/functional.py create mode 100644 torchsig/transforms/spectrogram_transforms/spec.py create mode 100644 torchsig/transforms/system_impairment/functional.py create mode 100644 torchsig/transforms/wireless_channel/functional.py create mode 100644 torchsig/version.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..dfc9d4a --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +__pycache__/ +*.pyc +*.mdb diff --git a/README.md b/README.md index c2cb443..691fe84 100644 --- a/README.md +++ b/README.md @@ -5,22 +5,25 @@ ----- -TorchSig is an open-source signal processing machine learning toolkit based on the PyTorch data handling pipeline. The user-friendly toolkit simplifies common digital signals processing operations, augmentations, and transformations when dealing with both real and complex-valued signals. TorchSig streamlines the integration process of these signals processing tools building on PyTorch, enabling faster and easier development and research for machine learning techniques applied to signals data, particularly within (but not limited to) the radio frequency domain. An example dataset based on many unique communication signal modulations is also included to accelerate the field of modulation recognition. +TorchSig is an open-source signal processing machine learning toolkit based on the PyTorch data handling pipeline. The user-friendly toolkit simplifies common digital signal processing operations, augmentations, and transformations when dealing with both real and complex-valued signals. TorchSig streamlines the integration process of these signals processing tools building on PyTorch, enabling faster and easier development and research for machine learning techniques applied to signals data, particularly within (but not limited to) the radio frequency domain. An example dataset, Sig53, based on many unique communication signal modulations is included to accelerate the field of modulation classification. Additionally, an example wideband dataset, WidebandSig53, is also included that extends Sig53 with larger data example sizes containing multiple signals enabling accelerated research in the fields of wideband signal detection and recognition. -*TorchSig is currently in beta (v0.1.0)* +*TorchSig is currently in beta* ## Key Features --- TorchSig provides many useful tools to facilitate and accelerate research on signals processing machine learning technologies: - The `SignalData` class and its `SignalDescription` objects enable signals objects and meta data to be seamlessly handled and operated on throughout the TorchSig infrastructure. -- The `Sig53` Dataset is a state-of-the-art static modulations-based RF dataset meant to serve as the next baseline for RFML development & evaluation. +- The `Sig53` Dataset is a state-of-the-art static modulations-based RF dataset meant to serve as the next baseline for RFML classification development & evaluation. - The `ModulationsDataset` class synthetically creates, augments, and transforms the largest communications signals modulations dataset to date in a generic, flexible fashion. +- The `WidebandSig53` Dataset is a state-of-the-art static wideband RF signals dataset meant to serve as the baseline for RFML signal detection and recognition development & evaluation. +- The `WidebandModulationsDataset` class synthetically creates, augments, and transforms the largest wideband communications signals dataset in a generic, flexible fashion. - Numerous signals processing transforms enable existing ML techniques to be employed on the signals data, streamline domain-specific signals augmentations in signals processing machine learning experiments, and signals-specific data transformations to speed up the field of expert feature signals processing machine learning integration. +- TorchSig also includes a model API similar to open source code in other ML domains, where several state-of-the-art convolutional and transformer-based neural architectures have been adapted to the signals domain and pretrained on the `Sig53` and `WidebandSig53` datasets. These models can be easily used for follow-on research in the form of additional hyperparameter tuning, out-of-the-box comparative analysis/evaluations, and/or fine-tuning to custom datasets. ## Documentation --- -Documentation can be built locally by following the instructions below. +Documentation can be found [online](https://torchsig.readthedocs.io/en/latest/) or built locally by following the instructions below. ``` cd docs pip install -r docs-requirements.txt diff --git a/docs/datasets.rst b/docs/datasets.rst index f796ce5..903634f 100644 --- a/docs/datasets.rst +++ b/docs/datasets.rst @@ -28,12 +28,24 @@ Sig53 .. autoclass:: Sig53 +WidebandSig53 +~~~~~~~~~~~~~~ + +.. autoclass:: WidebandSig53 + + ModulationsDataset ~~~~~~~~~~~~~~~~~~~~ .. autoclass:: ModulationsDataset +WidebandModulationsDataset +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: WidebandModulationsDataset + + DigitalModulationDataset ~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -70,6 +82,24 @@ FMDataset .. autoclass:: FMDataset +WidebandDataset +~~~~~~~~~~~~~~~~~~ + +.. autoclass:: WidebandDataset + + +SyntheticBurstSourceDataset +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: SyntheticBurstSourceDataset + + +FileBurstSourceDataset +~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: FileBurstSourceDataset + + RadioML2016 ~~~~~~~~~~~~~~ diff --git a/docs/models.rst b/docs/models.rst index 4f052c5..ad6b8c0 100644 --- a/docs/models.rst +++ b/docs/models.rst @@ -12,10 +12,14 @@ The following utilities are available: :local: +IQ Models +------------------ + + EfficientNet ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. currentmodule:: torchsig.models.efficientnet +.. currentmodule:: torchsig.models.iq_models.efficientnet.efficientnet .. autoclass:: efficientnet_b0 @@ -27,8 +31,84 @@ EfficientNet XCiT ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. currentmodule:: torchsig.models.xcit +.. currentmodule:: torchsig.models.iq_models.xcit.xcit .. autoclass:: xcit_nano .. autoclass:: xcit_tiny12 + + +Spectrogram Models +------------------ + + +YOLOv5 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. currentmodule:: torchsig.models.spectrogram_models.yolov5 + +.. autoclass:: yolov5p + +.. autoclass:: yolov5n + +.. autoclass:: yolov5s + +.. autoclass:: yolov5p_mod_family + +.. autoclass:: yolov5n_mod_family + +.. autoclass:: yolov5s_mod_family + + +DETR +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. currentmodule:: torchsig.models.spectrogram_models.detr + +.. autoclass:: detr_b0_nano + +.. autoclass:: detr_b2_nano + +.. autoclass:: detr_b4_nano + +.. autoclass:: detr_b0_nano_mod_family + +.. autoclass:: detr_b2_nano_mod_family + +.. autoclass:: detr_b4_nano_mod_family + + +PSPNet +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. currentmodule:: torchsig.models.spectrogram_models.pspnet + +.. autoclass:: pspnet_b0 + +.. autoclass:: pspnet_b2 + +.. autoclass:: pspnet_b4 + +.. autoclass:: pspnet_b0_mod_family + +.. autoclass:: pspnet_b2_mod_family + +.. autoclass:: pspnet_b4_mod_family + + +Mask2Former +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. currentmodule:: torchsig.models.spectrogram_models.mask2former + +.. autoclass:: mask2former_b0 + +.. autoclass:: mask2former_b2 + +.. autoclass:: mask2former_b4 + +.. autoclass:: mask2former_b0_mod_family + +.. autoclass:: mask2former_b2_mod_family + +.. autoclass:: mask2former_b4_mod_family diff --git a/docs/transforms.rst b/docs/transforms.rst index d8e0575..62d41ef 100644 --- a/docs/transforms.rst +++ b/docs/transforms.rst @@ -72,6 +72,22 @@ CutOut ^^^^^^^^^ .. autoclass:: CutOut +PatchShuffle +^^^^^^^^^^^^^ +.. autoclass:: PatchShuffle + +DatasetWidebandMixUp +^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: DatasetWidebandMixUp + +DatasetWidebandCutMix +^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: DatasetWidebandCutMix + +SpectrogramRandomResizeCrop +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SpectrogramRandomResizeCrop + Expert Feature Transforms ------------------------- @@ -159,6 +175,10 @@ RandomFrequencyShift ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: RandomFrequencyShift +RandomDelayedFrequencyShift +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: RandomDelayedFrequencyShift + LocalOscillatorDrift ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: LocalOscillatorDrift @@ -239,3 +259,32 @@ ImpulseInterferer RandomPhaseShift ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: RandomPhaseShift + + +Spectrogram Transforms +---------------------------- +.. currentmodule:: torchsig.transforms.spectrogram_transforms.spec + +SpectrogramResize +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SpectrogramResize + +SpectrogramDropSamples +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SpectrogramDropSamples + +SpectrogramPatchShuffle +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SpectrogramPatchShuffle + +SpectrogramTranslation +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SpectrogramTranslation + +SpectrogramMosaicCrop +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SpectrogramMosaicCrop + +SpectrogramMosaicDownsample +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SpectrogramMosaicDownsample diff --git a/docs/utils.rst b/docs/utils.rst index d082dd3..e75742d 100644 --- a/docs/utils.rst +++ b/docs/utils.rst @@ -52,4 +52,16 @@ Signal Visualizers .. autoclass:: TimeSeriesVisualizer -.. autoclass:: ImageVisualizer \ No newline at end of file +.. autoclass:: ImageVisualizer + +.. autoclass:: PSDVisualizer + +.. autoclass:: MaskVisualizer + +.. autoclass:: MaskClassVisualizer + +.. autoclass:: SemanticMaskClassVisualizer + +.. autoclass:: BoundingBoxVisualizer + +.. autoclass:: AnchorBoxVisualizer \ No newline at end of file diff --git a/examples/03_example_widebandsig53_dataset.ipynb b/examples/03_example_widebandsig53_dataset.ipynb new file mode 100644 index 0000000..4b983fd --- /dev/null +++ b/examples/03_example_widebandsig53_dataset.ipynb @@ -0,0 +1,469 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example 03 - Official WidebandSig53 Dataset\n", + "This notebook walks through how to use `torchsig` to generate the Official WidebandSig53 Dataset.\n", + "\n", + "-------------------------------------------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from tqdm import tqdm\n", + "import matplotlib.pyplot as plt\n", + "from torch.utils.data import DataLoader\n", + "\n", + "import torchsig.transforms as ST\n", + "from torchsig.datasets import WidebandModulationsDataset, WidebandSig53\n", + "from torchsig.utils.visualize import MaskClassVisualizer, mask_class_to_outline, complex_spectrogram_to_magnitude" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "-----------------------------\n", + "## Generate the Wideband Sig53 Dataset\n", + "To generate the WidebandSig53 dataset, several parameters are given to the imported `WidebandSig53` class. These paramters are:\n", + "- `root` ~ A string to specify the root directory of where to generate and/or read an existing WidebandSig53 dataset\n", + "- `train` ~ A boolean to specify if the WidebandSig53 dataset should be the training (True) or validation (False) sets\n", + "- `impaired` ~ A boolean to specify if the WidebandSig53 dataset should be the clean version or the impaired version\n", + "- `transform` ~ Optionally, pass in any data transforms here if the dataset will be used in an ML training pipeline. Note: these transforms are not called during the dataset generation. The static saved dataset will always be in IQ format. The transform is only called when retrieving data examples.\n", + "- `target_transform` ~ Optionally, pass in any target transforms here if the dataset will be used in an ML training pipeline. Note: these target transforms are not called during the dataset generation. The static saved dataset will always be saved as tuples in the LMDB dataset. The target transform is only called when retrieving data examples.\n", + "- `regenerate` ~ Optionally, pass in a boolean to specify if the dataset should be regenerated, even if an available one is detected\n", + "- `use_signal_data` ~ Optionally, pass in a boolean to specify if the annotations should be interpreted as `SignalData` objects as LMDB data is read. This is necessary when using the TorchSig pipeline; however, setting the value to False will simply return the annotations as a list of tuples as it is saved in the LMDB static data\n", + "- `gen_batch_size` ~ Optionally, pass in an integer to specify how many processes to spin up during the generation process. Note: this defaults to a single process and is recommended to remain a single process when generation occurs on the GPU.\n", + "- `use_gpu` ~ Optionally, pass in a boolean to specify if the data generation should occur on the GPU. Deafult behavior is True. Due to speed differences, it is highly recommended that generation occurs on the GPU. On a single V100, the WidebandSig53 dataset may take up to two days to complete its generation. Without a GPU, generation can take much longer.\n", + "\n", + "A combination of the `train` and the `impaired` booleans determines which of the four (4) distinct WidebandSig53 datasets will be instantiated:\n", + "- `train=True` & `impaired=False` = Clean training set of 250k examples\n", + "- `train=True` & `impaired=True` = Impaired training set of 250k examples\n", + "- `train=False` & `impaired=False` = Clean validation set of 25k examples\n", + "- `train=False` & `impaired=True` = Impaired validation set of 25k examples\n", + "\n", + "The final option of the impaired validation set is the dataset to be used when reporting any results with the official WidebandSig53 dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Existing data found, skipping data generation\n", + "Dataset length: 25000\n", + "Data shape: (2, 512, 512)\n", + "Label shape: (53, 512, 512)\n" + ] + } + ], + "source": [ + "# Specify WidebandSig53 Options\n", + "root = 'wideband_sig53/'\n", + "train = False\n", + "impaired = False\n", + "fft_size = 512\n", + "num_classes = 53\n", + "\n", + "transform = ST.Compose([\n", + " ST.Spectrogram(nperseg=fft_size, noverlap=0, nfft=fft_size, mode='complex'),\n", + " ST.Normalize(norm=np.inf, flatten=True),\n", + "])\n", + "\n", + "target_transform = ST.Compose([\n", + " ST.DescToMaskClass(num_classes=num_classes, width=fft_size, height=fft_size),\n", + "])\n", + "\n", + "# Instantiate the WidebandSig53 Dataset\n", + "wideband_sig53 = WidebandSig53(\n", + " root=root, \n", + " train=train, \n", + " impaired=impaired,\n", + " transform=transform,\n", + " target_transform=target_transform,\n", + " regenerate=False,\n", + " use_signal_data=True,\n", + " gen_batch_size=1,\n", + " use_gpu=True,\n", + ")\n", + "\n", + "# Retrieve a sample and print out information\n", + "idx = np.random.randint(len(wideband_sig53))\n", + "data, label = wideband_sig53[idx]\n", + "print(\"Dataset length: {}\".format(len(wideband_sig53)))\n", + "print(\"Data shape: {}\".format(data.shape))\n", + "print(\"Label shape: {}\".format(label.shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot Subset to Verify\n", + "The `MaskClassVisualizer` can be passed a `Dataloader` and plot visualizations of the dataset. The `batch_size` of the `DataLoader` determines how many examples to plot for each iteration over the visualizer. Note that the dataset itself can be indexed and plotted sequentially using any familiar python plotting tools as an alternative plotting method to using the `spdata` `Visualizer` as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_loader = DataLoader(\n", + " dataset=wideband_sig53,\n", + " batch_size=16,\n", + " shuffle=True,\n", + ")\n", + "\n", + "visualizer = MaskClassVisualizer(\n", + " data_loader=data_loader,\n", + " visualize_transform=complex_spectrogram_to_magnitude,\n", + " visualize_target_transform=mask_class_to_outline,\n", + " class_list=wideband_sig53.modulation_list,\n", + ")\n", + "\n", + "for figure in iter(visualizer):\n", + " figure.set_size_inches(16, 16)\n", + " plt.show()\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "----\n", + "### Analyze Dataset\n", + "The dataset can also be analyzed at the macro level for details such as the distribution of classes and number of signals per sample. The below analysis reads information directly from the non-target transformed tuple annotations. Since this is different than the above dataset instantiation, the dataset is re-instantiated for analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Existing data found, skipping data generation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 25000/25000 [09:34<00:00, 43.50it/s]\n" + ] + } + ], + "source": [ + "# Re-instantiate the WidebandSig53 Dataset without a target transform and without using the RFData objects\n", + "wideband_sig53 = WidebandSig53(\n", + " root=root, \n", + " train=train, \n", + " impaired=impaired,\n", + " transform=transform,\n", + " target_transform=None,\n", + " use_rf_data=False,\n", + ")\n", + "\n", + "# Loop through the dataset recording classes and SNRs\n", + "class_counter_dict = {\n", + " class_name: 0 for class_name in list(wideband_sig53.modulation_list)\n", + "}\n", + "num_signals_per_sample = []\n", + "\n", + "for idx in tqdm(range(len(wideband_sig53))):\n", + " data, annotation = wideband_sig53[idx]\n", + " num_signals_per_sample.append(len(annotation))\n", + " for signal_annotation in annotation:\n", + " class_counter_dict[signal_annotation[0]] += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqIAAAFUCAYAAAD/Il5qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABXMUlEQVR4nO3dd5gkVdn+8e8NS84IItEVRP0hAsISzCgGgoJZEAV5QfQVFbOoKKCimPBFERTJBhQJEgQEFASVBRZYdgkqWUCiZFEkPL8/zmmmpqa6p2qme2pn9v5cV13TXXXq1KmeDk+dVIoIzMzMzMwm2gJtF8DMzMzM5k8ORM3MzMysFQ5EzczMzKwVDkTNzMzMrBUORM3MzMysFQ5EzczMzKwVDkTNbEJJ2lfST9suR5GkMyXt3Ke8XiHpr4XnN0t6bT/yzvldLWnzfuU3L5F0vqTd2i6HmU0cB6Jm1neS3i1plqRHJN2RA72Xt1SWkPSvXJZ/SvqdpHcV00TEVhFxTM28ntsrTURcGBHPH2+58/GOlvTVUv4vjIjz+5F/6VjnS/pPfp0elHSBpBf1+RgL5wuR6/L/5GZJR0qa3s/jFI434vUzs3mLA1Ez6ytJnwD+D/gasBKwBnAIsF2LxVo/IpYEng8cDRwsaZ9+H0TStH7nOcE+nF+n5YHzgZ+MJZMer8MJwLbAu4FlgPWBy4AtxnKcUcqwYL/zNLP+cyBqZn0jaRngy8AeEXFSRPwrIh6PiNMi4tNd9vmVpDsLtXAvLGzbWtI1kh6WdLukT+X1K0g6XdIDku6TdKGkUb/PIuLeiPgJ8L/A5yQ9I+f3dJOwpOdK+kMuz72SfpnXX5CzuTLXGr5L0uaSbpP0WUl3Akd11pUOvXE+j/slHSVp0Zzn+yT9sfR6RC7D7sCOwGfy8U7L259u6pe0iKT/k/SPvPyfpEXytk7ZPinp7lwzvctor1F+nZ4EfgGsUyjXJpIuyq/5HZIOlrRwqdx7SLoOuK6cZy7z64DtIuLSiHgiIh6MiB9ExBGFpM+W9Kf8Pz9b0gqFPHq9V46WdKikMyT9C9i16vUzs3mLA1Ez66eXAIsCJzfY50xgbeCZwOXAzwrbjgA+EBFLAesCv8/rPwncBqxIqnX9PNDkfsWnANOATSq2fQU4G1gOWA34PkBEvDJvXz8iloyIX+bnzyLVID4b2L3L8XYE3gCsBTwP2Hu0AkbEYaTX4pv5eG+qSPYFYDNgA1Lt4ialvJ9FqnlclRSY/UDScqMdOweYOwIzC6ufBD4OrED6P28BfKi065uBTSkEsAWvBS6JiFtHOfy7gV1I74eFgU8VtvV6r3T23R9YCjiW0V8/M2uZA1Ez66dnAPdGxBN1d4iIIyPi4Yh4DNgXWD/XrAI8DqwjaemIuD8iLi+sXxl4dq5xvTAiageiEfE4cC8pgCx7nBRUrhIR/4mIP1akKXoK2CciHouIf3dJc3BE3BoR95ECpR3qlnUUOwJfjoi7I+IeYD/gvYXtj+ftj0fEGcAjpO4J3XxP0gPAw8CHc34ARMRlETEz12TeDPwIeFVp/69HxH1dXodnAHfUOKejIuJvOY/jSUF2pwy93isAp0TEnyLiqYj4T41jmVnLHIiaWT/9E1ihbl9JSQtKOkDSDZIeAm7OmzrNsW8DtgZuyc3lL8nrvwVcD5wt6UZJezUppKSFSLWp91Vs/gwg4BKlEer/M0p299QIeoq1gLcAq9QubG+r5Py65f3P0kXBo8CSPfL7aEQsCywGvBE4QdJ6AJKel7tD3Jn/V19j6P/U0au285+ki4fR3FlV3hrvldGOb2bzIAeiZtZPFwGPkZpo63g3aRDTa0lNyNPzegHkvoTbkZpif02qISPXin0yItYkDX75hKQmA162A54ALilviIg7I+L9EbEK8AHgEPUeKV+nJnb1wuM1gH/kx/8CFu9skPSshnn/g1R7W5X3mOUaxQtJwf7r8+pDgb8Aa0fE0qTuEGpQ3nOBTSStNsZi9XyvdDl+k+4aZtYCB6Jm1jcR8SDwJVJfxDdLWlzSQpK2kvTNil2WIgWu/yQFZF/rbFCa6mdHScvkpvSHSM3gSHpjHtAj4EFS/8WnRiufpOUl7Qj8APhGRPyzIs07CsHS/aRgppP3XcCaNV6Ksj0krSZpeVK/zk7/0iuBF0raIA9g2re032jHOw7YW9KKeVDPl4C+zNGaa5/XAa7Oq5Yi/Q8ekfQC0oCv2iLiXOAc4GRJG0maJmkpSR+sUevcOX7le6WHsf6/zGyCOBA1s76KiO8AnyANmrmH1Fz6YVKNZtmxpObk24FrGD44BlJ/x5tzU+wHSX0iIQ1YOZfU5/Ei4JCIOK9Hsa6U9Aiphm834OMR8aUuaTcGLs7pTwX2jIgb87Z9gWPyyPF39jhe2c9JA6BuBG4AvgoQEX8jzTJwLmmkebk/6hGkPrIPSPp1Rb5fBWYBc4C5pAE845k38+A8wvwR0tRNe0fEmXnbp0i1kg8DP2YomG7i7cAZed8HgauAGaTzH81o75Uqo71+ZtYyNejfb2ZmZmbWN64RNTMzM7NWOBA1MzMzs1Y4EDUzMzOzVjgQNTMzM7NW1Jp0ejJaYYUVYvr06W0Xw8zMzGy+dtlll90bEStWbZuygej06dOZNWtW28UwMzMzm69JuqXbNjfNm5mZmVkrHIiamZmZWSsciJqZmZlZKxyImpmZmVkrHIiamZmZWSsciJqZmZlZKxyImpmZmVkrHIiamZmZWSsciJqZmZlZK6bsnZXMbLjpe/2m5/abD9hmgkpiZmaWuEbUzMzMzFrhQNTMzMzMWuFA1MzMzMxaMbBAVNLqks6TdI2kqyXtmdcvL+kcSdflv8vl9ZL0PUnXS5ojacNCXjvn9NdJ2nlQZTYzMzOziTPIGtEngE9GxDrAZsAektYB9gJ+FxFrA7/LzwG2AtbOy+7AoZACV2AfYFNgE2CfTvBqZmZmZpPXwALRiLgjIi7Pjx8GrgVWBbYDjsnJjgHenB9vBxwbyUxgWUkrA28AzomI+yLifuAcYMtBldvMzMzMJsaE9BGVNB14MXAxsFJE3JE33QmslB+vCtxa2O22vK7b+qrj7C5plqRZ99xzT/9OwMzMzMz6buDziEpaEjgR+FhEPCTp6W0REZKiX8eKiMOAwwBmzJjRt3zNbHxGm8MUPI+pmdn8aKA1opIWIgWhP4uIk/Lqu3KTO/nv3Xn97cDqhd1Xy+u6rTczMzOzSWyQo+YFHAFcGxEHFjadCnRGvu8MnFJYv1MePb8Z8GBuwv8t8HpJy+VBSq/P68zMzMxsEhtk0/zLgPcCcyXNzus+DxwAHC9pV+AW4J152xnA1sD1wKPALgARcZ+krwCX5nRfjoj7BlhuMzMzM5sAAwtEI+KPgLps3qIifQB7dMnrSODI/pWuv9z/zczMyvzbYDY631nJzMzMzFox8FHzZtaMa1HMzGx+4UDUJr3RArdBBm0OGs3MzMbOgaiZ2YC1ebFkZjYvcyA6n6n7g+iaPjMzMxs0B6JmZlOYLyrNbF7mQNTMzKwBd7Uw6x8HomZmk5CDITObChyImtmk5CZnM7PJz4HoFOAf5Hr8OpnZ/MTfeTYZOBA1M7OBcTBkZr34Fp9mZmZm1grXiJqZGeABUGY28RyImpkVOBgzM5s4DkQnmH/krJ+m4vtpKp6TmZlVcyA6D/MPspnZSB4AZTZ1DCwQlXQk8Ebg7ohYN6/7JfD8nGRZ4IGI2EDSdOBa4K9528yI+GDeZyPgaGAx4Axgz4iIQZXbzKwOB0OTw1S8oJ+K52Tzr0HWiB4NHAwc21kREe/qPJb0HeDBQvobImKDinwOBd4PXEwKRLcEzux/cW3Q/MNtZr04wDKb/wwsEI2IC3JN5wiSBLwTeE2vPCStDCwdETPz82OBN+NAdJ4yiB8P/yCZmZlNfW31EX0FcFdEXFdY9xxJVwAPAXtHxIXAqsBthTS35XWVJO0O7A6wxhpr9L3QZmY2NbnFxqwdbQWiOwDHFZ7fAawREf/MfUJ/LemFTTONiMOAwwBmzJjhfqRmZgPiVgsz64cJD0QlTQPeCmzUWRcRjwGP5ceXSboBeB5wO7BaYffV8jqzSWey/HC7ZsjMzCZKG7f4fC3wl4h4usld0oqSFsyP1wTWBm6MiDuAhyRtlvuV7gSc0kKZzczMzKzPBhaISjoOuAh4vqTbJO2aN23P8GZ5gFcCcyTNBk4APhgR9+VtHwIOB64HbsADlczMzMymhEGOmt+hy/r3Vaw7ETixS/pZwLp9LZzZKCZLM7rV4/+nzevcJcbmV200zZuZmZmZ+RafZmbzCteKmdn8xjWiZmZmZtYKB6JmZmZm1goHomZmZmbWCvcRNbMx82h0MzMbD9eImpmZmVkrHIiamZmZWSsciJqZmZlZKxyImpmZmVkrHIiamZmZWSsciJqZmZlZKxyImpmZmVkrHIiamZmZWSsciJqZmZlZKxyImpmZmVkrBhaISjpS0t2Sriqs21fS7ZJm52XrwrbPSbpe0l8lvaGwfsu87npJew2qvGZmZmY2sQZZI3o0sGXF+u9GxAZ5OQNA0jrA9sAL8z6HSFpQ0oLAD4CtgHWAHXJaMzMzM5vkpg0q44i4QNL0msm3A34REY8BN0m6Htgkb7s+Im4EkPSLnPaafpfXzMzMzCZWG31EPyxpTm66Xy6vWxW4tZDmtryu2/pKknaXNEvSrHvuuaff5TYzMzOzPproQPRQYC1gA+AO4Dv9zDwiDouIGRExY8UVV+xn1mZmZmbWZwNrmq8SEXd1Hkv6MXB6fno7sHoh6Wp5HT3Wm5mZmdkkNqE1opJWLjx9C9AZUX8qsL2kRSQ9B1gbuAS4FFhb0nMkLUwa0HTqRJbZzMzMzAZjYDWiko4DNgdWkHQbsA+wuaQNgABuBj4AEBFXSzqeNAjpCWCPiHgy5/Nh4LfAgsCREXH1oMpsZmZmZhNnkKPmd6hYfUSP9PsD+1esPwM4o49FMzMzM7N5gO+sZGZmZmatcCBqZmZmZq1wIGpmZmZmrXAgamZmZmatcCBqZmZmZq1wIGpmZmZmrXAgamZmZmatcCBqZmZmZq1wIGpmZmZmrXAgamZmZmatcCBqZmZmZq1wIGpmZmZmrXAgamZmZmatcCBqZmZmZq1wIGpmZmZmrXAgamZmZmatGFggKulISXdLuqqw7luS/iJpjqSTJS2b10+X9G9Js/Pyw8I+G0maK+l6Sd+TpEGV2czMzMwmziBrRI8GtiytOwdYNyLWA/4GfK6w7YaI2CAvHyysPxR4P7B2Xsp5mpmZmdkkNLBANCIuAO4rrTs7Ip7IT2cCq/XKQ9LKwNIRMTMiAjgWePMAimtmZmZmE6zNPqL/A5xZeP4cSVdI+oOkV+R1qwK3FdLcltdVkrS7pFmSZt1zzz39L7GZmZmZ9U3jQFTScpLWG89BJX0BeAL4WV51B7BGRLwY+ATwc0lLN803Ig6LiBkRMWPFFVccTxHNzMzMbMCm1Ukk6Xxg25z+MuBuSX+KiE80PaCk9wFvBLbIze1ExGPAY/nxZZJuAJ4H3M7w5vvV8jozMzMzm+Tq1oguExEPAW8Fjo2ITYHXNj2YpC2BzwDbRsSjhfUrSlowP16TNCjpxoi4A3hI0mZ5tPxOwClNj2tmZmZm8566gei0PHDoncDpdXaQdBxwEfB8SbdJ2hU4GFgKOKc0TdMrgTmSZgMnAB+MiM5Apw8BhwPXAzcwvF+pmZmZmU1StZrmgf2A3wJ/jIhLc63ldb12iIgdKlYf0SXticCJXbbNAtatWU4zMzMzmyTqBqJ35Lk/AYiIGyUdOKAymZmZmdl8oG7T/PdrrjMzMzMzq6VnjaiklwAvBVaUVBwhvzSw4CALZmZmZmZT22hN8wsDS+Z0SxXWPwS8fVCFMjMzM7Opr2cgGhF/AP4g6eiIuGWCymRmZmZm84G6g5UWkXQYML24T0S8ZhCFMjMzM7Opr24g+ivgh6T5PJ8cXHHMzMzMbH5RNxB9IiIOHWhJzMzMzGy+UjcQPU3Sh4CTyfeEByjc/cjMzMymuOl7/WbUNDcfsM0ElMSmirqB6M7576cL6wJYs7/FMTMzM7P5Ra1ANCKeM+iCmJmZmdn8pVYgKmmnqvURcWx/i2NmZmZm84u6TfMbFx4vCmwBXA44EDUzM7P5wmh9ZN0/trm6TfMfKT6XtCzwi0EUyMzMzCa/QQRtUzEQnIrn1ETdGtGyfwHuN2pmZmbj4pH487e6fURPI42SB1gQ+H/A8YMqlJmZmdlEmIqB8GSqZa1bI/rtwuMngFsi4rbRdpJ0JPBG4O6IWDevWx74Jel2oTcD74yI+yUJOAjYGngUeF9EXJ732RnYO2f71Yg4pma5zczMzGweVbeP6B8krcTQoKXrauZ/NHAwwwc17QX8LiIOkLRXfv5ZYCtg7bxsChwKbJoD132AGaRa2csknRoR99csg5mZmfUwmWrQbGpZoE4iSe8ELgHeAbwTuFjS20fbLyIuAMp3X9oO6NRoHgO8ubD+2EhmAstKWhl4A3BORNyXg89zgC3rlNvMzMzM5l11m+a/AGwcEXcDSFoROBc4YQzHXCki7siP7wRWyo9XBW4tpLstr+u2fgRJuwO7A6yxxhpjKJqZmZnZ+Ayi3+lU7MsK9QPRBTpBaPZPatam9hIRISlGT1k7v8OAwwBmzJjRt3zNzMxscnF3g8mhbjB5lqTfSnqfpPcBvwHOGOMx78pN7uS/nQD3dmD1QrrV8rpu683MzMxsEusZiEp6rqSXRcSngR8B6+XlInLN4xicCuycH+8MnFJYv5OSzYAHcxP+b4HXS1pO0nLA6/M6MzMzM5vERmua/z/gcwARcRJwEoCkF+Vtb+q1s6TjgM2BFSTdRhr9fgBwvKRdgVtIg58g1bBuDVxPmr5pl3zc+yR9Bbg0p/tyRJQHQJmZmZnZJDNaILpSRMwtr4yIuZKmj5Z5ROzQZdMWFWkD2KNLPkcCR452PDMzMzObPEbrI7psj22L9bEcZmZmZjafGS0QnSXp/eWVknYDLhtMkczMzMxsfjBa0/zHgJMl7chQ4DkDWBh4ywDLZWZmZmZTXM9ANCLuAl4q6dXAunn1byLi9wMvmZmZmZlNaXXvNX8ecN6Ay2JmZmZm85Fx3x3JzMzMzGwsHIiamZmZWSsciJqZmZlZKxyImpmZmVkrHIiamZmZWSsciJqZmZlZKxyImpmZmVkrHIiamZmZWSsciJqZmZlZKxyImpmZmVkrHIiamZmZWSsmPBCV9HxJswvLQ5I+JmlfSbcX1m9d2Odzkq6X9FdJb5joMpuZmZlZ/02b6ANGxF+BDQAkLQjcDpwM7AJ8NyK+XUwvaR1ge+CFwCrAuZKeFxFPTmS5zczMzKy/2m6a3wK4ISJu6ZFmO+AXEfFYRNwEXA9sMiGlMzMzM7OBaTsQ3R44rvD8w5LmSDpS0nJ53arArYU0t+V1I0jaXdIsSbPuueeewZTYzMzMzPqitUBU0sLAtsCv8qpDgbVIzfZ3AN9pmmdEHBYRMyJixoorrtivopqZmZnZALRZI7oVcHlE3AUQEXdFxJMR8RTwY4aa328HVi/st1peZ2ZmZmaTWJuB6A4UmuUlrVzY9hbgqvz4VGB7SYtIeg6wNnDJhJXSzMzMzAZiwkfNA0haAngd8IHC6m9K2gAI4ObOtoi4WtLxwDXAE8AeHjFvZmZmNvm1EohGxL+AZ5TWvbdH+v2B/QddLjMzMzObOG2PmjczMzOz+ZQDUTMzMzNrhQNRMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2uFA1EzMzMza0VrgaikmyXNlTRb0qy8bnlJ50i6Lv9dLq+XpO9Jul7SHEkbtlVuMzMzM+uPtmtEXx0RG0TEjPx8L+B3EbE28Lv8HGArYO287A4cOuElNTMzM7O+ajsQLdsOOCY/PgZ4c2H9sZHMBJaVtHIL5TMzMzOzPmkzEA3gbEmXSdo9r1spIu7Ij+8EVsqPVwVuLex7W143jKTdJc2SNOuee+4ZVLnNzMzMrA+mtXjsl0fE7ZKeCZwj6S/FjRERkqJJhhFxGHAYwIwZMxrta2ZmZmYTq7Ua0Yi4Pf+9GzgZ2AS4q9Pknv/enZPfDqxe2H21vM7MzMzMJqlWAlFJS0haqvMYeD1wFXAqsHNOtjNwSn58KrBTHj2/GfBgoQnfzMzMzCahtprmVwJOltQpw88j4ixJlwLHS9oVuAV4Z05/BrA1cD3wKLDLxBfZzMzMzPqplUA0Im4E1q9Y/09gi4r1AewxAUUzMzMzswkyr03fZGZmZmbzCQeiZmZmZtYKB6JmZmZm1goHomZmZmbWCgeiZmZmZtYKB6JmZmZm1goHomZmZmbWCgeiZmZmZtYKB6JmZmZm1goHomZmZmbWCgeiZmZmZtYKB6JmZmZm1goHomZmZmbWCgeiZmZmZtYKB6JmZmZm1goHomZmZmbWigkPRCWtLuk8SddIulrSnnn9vpJulzQ7L1sX9vmcpOsl/VXSGya6zGZmZmbWf9NaOOYTwCcj4nJJSwGXSTonb/tuRHy7mFjSOsD2wAuBVYBzJT0vIp6c0FKbmZmZWV9NeI1oRNwREZfnxw8D1wKr9thlO+AXEfFYRNwEXA9sMviSmpmZmdkgtdpHVNJ04MXAxXnVhyXNkXSkpOXyulWBWwu73UaXwFXS7pJmSZp1zz33DKrYZmZmZtYHrQWikpYETgQ+FhEPAYcCawEbAHcA32maZ0QcFhEzImLGiiuu2M/impmZmVmftRKISlqIFIT+LCJOAoiIuyLiyYh4CvgxQ83vtwOrF3ZfLa8zMzMzs0msjVHzAo4Aro2IAwvrVy4kewtwVX58KrC9pEUkPQdYG7hkosprZmZmZoPRxqj5lwHvBeZKmp3XfR7YQdIGQAA3Ax8AiIirJR0PXEMacb+HR8ybmZmZTX4THohGxB8BVWw6o8c++wP7D6xQZmZmZjbhfGclMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2uFA1EzMzMza4UDUTMzMzNrhQNRMzMzM2vFpAlEJW0p6a+Srpe0V9vlMTMzM7PxmRSBqKQFgR8AWwHrADtIWqfdUpmZmZnZeEyKQBTYBLg+Im6MiP8CvwC2a7lMZmZmZjYOioi2yzAqSW8HtoyI3fLz9wKbRsSHS+l2B3bPT58P/HVCCzrcCsC9fUzXdp5tH3+y5Nn28efnPNs+/mTJs+3jT5Y82z7+ZMmz7eNPljzbPn6TPAfh2RGxYuWWiJjnF+DtwOGF5+8FDm67XKOUeVY/07WdZ9vHnyx5tn38+TnPto8/WfJs+/iTJc+2jz9Z8mz7+JMlz7aP3yTPiV4mS9P87cDqheer5XVmZmZmNklNlkD0UmBtSc+RtDCwPXBqy2UyMzMzs3GY1nYB6oiIJyR9GPgtsCBwZERc3XKxRnNYn9O1nWfbx58sebZ9/Pk5z7aPP1nybPv4kyXPto8/WfJs+/iTJc+2j98kzwk1KQYrmZmZmdnUM1ma5s3MzMxsinEgamZmZmatcCBqZmZmZq1wINonkjaqWPfGLmmXr1j3nHEef5GxHkfSxuM5dsPj9/3cJytJC0haug/51H7vtWmylLNtdT9L80CeqnOctvMcVL6DKqvZ/MaBaP/8WNK6nSeSdgC+2CXtacUARNI6wGnlRJIWlLStpI9K+kRn6ZLnSZIWKuy7MnBORboTJa1aSPcq4MiqDAd0/FrnPplIeqOkKyTdJ+khSQ9LeqhL2p9LWlrSEsBVwDWSPl2RboakkyVdLmmOpLmS5nQpQu33nqStKtZ9cJznVLesfS9nE03ez5Jelv9HSHqPpAMlPXucx9+1Yt0BFUnrfpYGlWfd1/6IUpolgTPmwTxr5zuIPPO2uhfqTSo0al9cNL0IlLRtt211SVpY0k6SXpufv1vSwZL2KL4X87ZlJL2r8Ll8l6RlK/LctPP7IWkxSftJOk3SNyQtU0qrnP6tedlUGnnxkNO+QNIW+X9YXL/lWMrZNG3Fvn+rWDdN0gcknZW/Z+dIOlPSBytez+UlfUnSbvl1+IKk0yV9S9JydcowkRyI9s/bgWPzG/r9wIeA13dJ+zVSQLZk/oL4FfCeinSnAe8DngEsVViq/Bo4Pv/YTidNdfW5inQfAH4t6VmStga+B2zdJc9BHL/uuT9NKXBbvrN0SdMkcKobjNX9kf8/YGfgGRGxdEQsFRHdajrXiYiHgDcDZwLPId0prOxnwFHA24A3AW/Mf6s0ee99UdJrCufzGWC7cZ5T3bIOopxIWqvzoyxpc6VAc9mKpE3ez4cCj0paH/gkcANwbMWxl83HO1DS9zpLlzzfJmnHwr4/AKpuefdr6n2WBpVn3df+NkmH5DTLAWcDP50H82yS7yDyhPoXAk0qNGpfXPTKtxCodZa3AYd1nhczkfQiSTMl3SrpsGJQI+mS0jGPArYB9pT0E+AdwMXAxsDhhf12Ai4HNgcWz8urgcvytqIjgUfz44OAZYBv5HVHFfJ8PXAdsC/p921rYD/guryteE4fBU4BPgJcJan4//7aWMrZMO3D+Ter87v1MLBWxW/YT4ANKs5pfUa+734KLAFsBJwHPCu/Tv8GjmZe0/atnabSAjwPuAY4C1hslLRvBv4MzAWe1yXNnIbH34P0YzsXeGmPdC8B5gCXACv2SDeo44967jndB4A7gZuBm/JyY5e01wPrkackG6WcfwZeU3j+GeDMinRnADsWnv8AOKIi3XnAAjVfo6uBhUgB+Kvyuisr0v1xEO890v2GZwKvAPYHTgQWHuc51S5rv8uZ084mzYn8XOBvwLeAM8bzfgYuz3+/BOxaXFfxXjoQ2IUUuO8M7Nwlz8VIgcIOwDHAQT2OX/ezNIg8m7z23wR+SLrpyNvm1Tzr5juIPHO69wMnk+bBnk76/n19Rbo1SQHMC/I+FwLLjCfP0fIFHgdOJwV5R+Xl4fz3yFI+fwS2BJYFPkX6Plsrb7ui6vNG+mzeBSyYn4vCZxH4K7BsRZmXA/5WWndt+TNaeD67mA6YXpHnc4p55HVzgSXz4+nALGDP8jk1LGeTtN8jXeSuVFh3U8W+fyuv67at81rk1/r2bq/TvLJMignt52WS5gLFyViXJ30xXCyJiFivkPb7pbTLkGpaPpzTfrSU/ZmSXh8RZ/c4frFpUcAapB/mzSRtFhEH5nSnlY69OPAgcEQ+dlVTTD+P3/TcIX3RrRsR93Y7fsGtwFWRP2mj2BY4XalJfEvSl3NVrcfbgFMlPZXTPRARI2pJSYHsGZL+ADzWWdk595IfkQLrK4ELlJp7q2pu95F0OPC7Up4ndR43ee8V9r9XqdntXOAy4O1dXrMm59SzrAMuJ8BTkW568Rbg+xHxfUlXVKQb9f1c8LCkz5Fq618paQHSBUTZohHRrbsKMKK5dDdS7eSfgP0kLR8R9+V0tT5Lg8qzY7TXvlRLdjGpZu0SICS9tfgebTPPseQ7iDxzvj9Wuivgr0nBzgci4s8V6W6UtH1O93dSYPnvcromedbI96XAAcClEXFoPsfNI2KXiqyWioiz8uNvS7oMOEvSexn+GQdYIJdvCdLvzTLAfcAiDP8sqWJfgKfytqKrJO0SEUcBV0qaERGzJD2PFFB3TANuq8jzdkZ+jheIiEcAIuJmSZsDJ+Tv5uLxm5SzdtqI+KhS6+Bxkn4NHNxl3/skvQM4MSKeAsjfS+8A7i+fU66tXgpYUtL0fG7PABauyLtVDkTHr8lgi1ml55eNkn4mcHJ+sz1OfnPH8CbSctPiSV3Wf7tBOQdx/KbnDilQfXTUVEntwKnGj2KtH/mC/YFHgEUZ5UMeEd8jXQF33CLp1RVJdyEFyAuRvrwgfTkVf+Rqv/dyc08w9AW5MKmW5O2Syv9TaHBONco6yHICPJ6bGndmqEtAVdBY5/3c8S7g3aTa0DslrUGqaS37iVI3g9MZ/r4rvkcuK52TSE2W2+Tna+Z0dT9LA8mzwWtf7nZxBen1fhOl92jLedbOdxB55nzrXqg3qdBocsEyar4Rcamk1wEfkXQe8NnSPsNIWiYiHgSIiPOUmvJPzHkXHQH8JR/vC8CvJN0IbAb8opBuf+BySWeTKhTI5/Q64CulPHcDDpK0N3AvcJGkW/N+uxXSHQlcKukXhTxXJ90efFjfXuAuSRtExOx8To8o9Z89EnjRGMvZJC0RcZlSX9oPA38gfe+WbU9qXj9E0v2k//2ywO/ztqKvk157gP8BDlfqHvv/SM358xTfWamPlPqTvSI/vTAirqyxz3LA6hExYnCHpJtINXVza9b0dfZbgNTUMKKmTWkAxr8j4ql8FfkCUrP04xVp+378Urqu5563v5jUPHQxw3/kR9Se5g/8I6RmlqcKafcrpKn6sXkiP376xyafd/lHvpBlrFl4jqSrImJdapC0J0NNX4cDLwb2KtfSSfprRDy/Zp5rAbdFxGP5an494NiIeKDO/l3ybHJOtco6iHLmfNcBPghcFBHHKc3C8M6I+EYpXe33c/6c/Ccinuz1OZG0B+lH5wGGfrxHvEfGqu5nqe08rZqkfXpt73w/aZSBcBFxS9M8m+ab068KfBeYUfUelvRuUveomaX1awBfjIj3l9avko/zD6V+268F/h4Rl5TSLQe8AegMpL0d+G1ElGv6OumXJjWzTyN9p9xVkWYdUutXMc9TI+KaUrrVgCci4s6KPF4WEX8aSzmbnlNhv5WBF0dE5cC3nOYZABHxzx5pFiTFeE9ImkbqX3p7RNzR6/itiHmgf8BUWIA9SaOgv5yXucBHuqQ9H1iadAV5EynQOrAi3QXU76f385znEqQ+eLcBn65IdxmpmWRVUhPxr4CfdclzEMevde457SXU7393VYv/+2/SpW9WRdor8983kGpOXkh138OjSAOb6uQ5mxp9JHPalwFL5Mfvya/vGuM8p1plHUQ5K/ZbDlivD+/nWp8T4EZghZp5voPUtAmwd/7/v7giXa3P0gDzbPIeWZpUG/g74B7gPfNank3yHUSeFfstACzdZdtawCL58ebAR6noa9gkz/HkO1ELMK3weElgBrB8zX17piP91tTKq2LfJSvWrQRsmJeVRtm/Vtr8PlqrYv16pecvINVYd1rWPgu8oOa5fK3t/3PXsrVdgKmykDqKL1F4vgRdBkeQO0CTmhL26+xfke5o0o/n54BPdJYuec7Of3cEvpO/HKvy7AzC+Ajwmfx4xGCZAR6/1rkX09Z8/ZsETnV/FOv+yD9MqoX9N6m/58PAQ93eJ/nvQcBbup0nqbP9f0md3ueQLmy6vU6d/+lnyBc/3V67nJdIIy2vIA1g+cM4z6lWWQdRzpz2fOpd2DV5P9f6nJBGSi9e833X+d+/PJd5G+DisX6WBplnzfdIJ8+3kJo7l6l6jdrOs0m+g8gzp6l7oT6b+hdrTS4uuuZLag5eIT9+Lukzcj/pc/SiUj4n5ffQiACt4pjrkbrD3AocBixX2HZJ4fH7gH/mcm1Furj7Xd5vh1Keexcer5P3uYl0sbhpYdsapOb/u0mj56/Pj39BxSCmHufw98LjDfL5XEsaIHguqfl7JrBhab8mad8J/CP/j64GNi5su7zw+LM5zV6k36335MezSa1qxTy/V1q+T2q1+R7wvbrnP1GL+4j2j4AnC8+fZGQH5o5pufr9naS+M93clJeFGb2f3kJKU3m8GTg4Ih6XFFXllPQS0pdJZ+BNt2m8BnH8uucOaXDJ7qSRvt3633X8L/ApSY8xev+/Q4H1NTQ1z+GkqTFeVUr3xYj4laSXk5qUvkUaIbtpMVFEdJsCqMpluRvBc4DPSVqKQleCgi0r1nXT6SO5E737SEJqggqlKUoOjogjVDFNVcNzqlvWvpczWyYiHpK0G6mpfx9Vz2Pa5P1c93PyL2B27lvXs/sIQ98P2wCHRcRvJH21Il3dz9Kg8qz72nf+d9sAv4qIB1U9TWOTPDu/Sf3Ms0lZm+TZpKzr5PfojqRp2/Yi1bqX+x13Bt69ld4D75rkOVq+/xsRB+fHBwHfjYiTc/eZH5Iu3Ds2JX1ffV/SucBxwG8i4r8VxzyENNXQTFLFwx8lbRsRNzD8c/9J4PmkfstXki72b5C0EimIO66Q9q1A5/39LdLo9jMlbUKacu6ledsv8/MdI+JJeLqp+h2kYHSzTobqPje2SLWzHUeTBoRdPCyRtBmpVWj9Mab9PLBRRNyRz+Mnkj4XESczPIbYFXhhjOwedCApgC1OLfgWUl/Tswt5bE+9sRkTzoFo/xxF6gDeefO8mS4TxZOa7n8L/ClSR/E1SVdtw0Shr08NdUdjf4xUI3RyRFydj31eVYYDOn6tc892yH+L8x0GQwMximVtEjjV/bGp+yPf6Q+0NoVO5hFxQUXSXUlXyzdGxKO5r8+I0amR+25JeibVHdeLdiH1kdw/Im7KfSR/0iVtZzT4e4FXqPto8Nrn1KCsAyknNS9uGr6fP0a9z8mv81LH7ZJ+RBqw8A2luU+rgtu6n6VB5Vl3xoDTJP2FVGv+v5JWBP4zzjxPH0CeTcraJM8mZa17IdDkYq3JxUWvfItxwDNzAEREnJ8vlIvujoi35z6a25GmgjpM0unAcTG8r3vdEfZPRpoZ5V5Jj+RAlYi4q0dgD7BKRJyZ014iabHCthUi4pfFxDkg/YWk8mChr5GC2icqjlH8LC1RDixzvjOVb34xxrQLRu63mc/j1aT31uoMf52eAlYBbintvzIjKzPWIQ2K2hL4VKQ+uvtExDEV59i+iap6nR8WUj+Qj5Ka80Y04Y4hvxXJTSikkXG/B37fYP9pPbYtTW52buP4A3r9lwM2AV7ZWbqk+wMpyPgbaaLfBUgDWMrpTif9gN9IGp24CNXNebuRmqPvJwUr/+71OpE60H87L2/qkeY6Uo3bTaQvmqv78Bo9i9Qk/Yr8fA1gp/Gc0yDKWreceds7SE2qh+bna5KmOBn3+5lUIzJqM+QoeTwn/12cVKOzdn6+MoXuJAzNXfiy0v7q9lkaLc9RyjWt9LzTh7Dnaw+8o3Ne5FHY+fkSwLP68P8s5rl4Oc+65RxLWZuUs05ZC+k+Shqsckb+fz6bNKC1nG4dUvPpDoVyf3Y8eY6WL2mw3dGkz83nSRdhzyZdOJ5eyqeqP/szSBeYvy+tv5LSHKik5vrrgH8W1p1KGuV9MOkz+R1SLew+pME9xf0fyOlPI/XJXbyw7arC41+QamQ3JQVvq+THhwDHl/L8M6lGsup1u7Xw+HvAb0gzarw0L+/K6w4u7dck7Z8p9Q8l1Q7/DnissG5LUheDM0ldHQ4jzcd8PbBll/J3JrT/FHBzne+FNpbWCzBVlvylMJc0NcKXST+M3QYrrVn4IN1NuqvDmhXpzibVoF1LajY+EvhGjzJsQ+p/96XOUpFmRi7nzaQrqyt7fAgHcfxa515Ivy6ppmunztIlXZPAqW4wVutHPh93UYb6jL0AOKnLsQ/IXzD/k5dzqOhEnv8vz2CoT+2rqZhMP29bGziB1E/sxs7S4zV9Fil4fBPdfzibnFOtsg6inA0/o7Xfz6RpW67In5G/k5q0XjiWcwIuy39/N0r5Oq/1iB/7UfZbjvQD3xkUsWFFmmVJ31EHUug7VkrT6Rf7k1GOd/lYypn36fTlrRxAQprqZ9tc1sp+vHXLOZ6yjlbOBmXdM//teXHReW90ez82KPeYLv5J/TQvJk2J9HB+P3+NkYHkBQ3yfDewWcX6NYAfl17rz5G6FixJmr/5dNINRFYu7fuq0tKZiH4lYI9CuoVJ3bXOIn2Xzc2PP0S+kCmkfT5dBhxSGmBE6sP6Q9Jv2Gn58dZd9q2VltRMv3bF+oUo3FAlr1uA1K3gbXnZjHwh1OP/IFJf55+O5701yMXTN/VJ7pP2koj4V36+BGk6mfUq0s4kfcg6fV+2JwWtm5bSXRYRG0ma08lH0qURsXFFnj9k6DZih5Nup3hJlCZgz+XcIyIuzM9fDhzSpZyDOH6tc89p9yGN8FyHdNW/FekuPm+vSDuXdOu4mRGxgaQXkAK8t5bTNiFpQ9JAkCB1J7i8Is2lEbGxpNmkDvOPSbo6Il5YkXYOsEEMTUi8ICmAW6+UblZEzJDU6TP1lKQrI2L9ijz/SKo9+C4paNuFNDr8SxVpdyNdJPye9AX1KuDLEXFkKV2Tc6pV1kGUM6ddjdQZv9OX7UJSAHBbKV2T9/OfgS9ExHn5+eak99NLS+lGPafcF+9XpB/G75aPFUNzSR5HulBchTSH7tNZpGSVn9GvkIKIGxg+fdRrKs5nJiOnNzumkOYqUvDxFeDTFeU8Kac7Jx9rY9JrXU63bUU5P0C6SP9PqZxrltKdkdP0moatVjnHUta65WxQ1tn5++jyiNiwnEch3TWki+kjSAHcsDbpLt87y5IuzqdTaF6P6unt3kh6vZ6d0/bqQ28tUOoT+/RUT1ExJdW8kOdAtB0JT5WFXINUeL4oFc29eVvViOKqJt+Z+e9vSbWNLwZu6JVn4e+SVDf9XFGxrrK2YEDHr3Xuhdd0AYamPFoJOKdL2kvz39kMNd1VNg+TriIvJc07+l9SX9AHK9J9iaFa7v1INX97V6Q7mVTjtC9pxOkpdB/pOodCDQupxqXqNTk3v4YHk4L2g4A/d8mzU+M2t7yuIu1fSfeP7zx/BvDXcZ5TrbIOopx52zmkAHBaXt5X9T5p+H6u+jxWrRv1nEg1Lp8F7iAFrcXlS6W0z8rvs2eXlx6vU9dbUBbSjVojSLrgOpQ0gvmovBxJ6VaPpNqmzUhNrOUaqld1yfs6akxzVfVZGGs5x1LWuuVsUNbjGOq2MqewDJtZgnThfiapNvK80tKtZafJ7WVr3wI5pz+sTrqmaZvuU05HqoX+ACmoLtcyF0fUL05qnfs06bd4Z1KT/jcpdbWhMEUSqRZy75z2awxv+i/OLrAWvWcXWCD/X04nfZ4vJ3UX2LziHDdgaIT9uQwfYf/iYjmpMQtBjTxHtJi0vbRegKmykJplriT9cO9LCog+1iXtN0hNEdNJPzKfIfWRGdYMRLojzTKk5unzSM2D23bJ8+L8dyapRmUR4PqKdP9H6ve4OenL+JD8ZTaiSa/h8S+pefxvkJpgep57Kc/LSM03Av7S5fhNAqdZpGlKriB9se0CfL0i3V8ZfnGxGF2CoUKaV5Ga67rdR3t7UnPv0aR7g98EvKsi3RK5bNNIX6IfpRCYldL+mfTFdxLpy/It3cqZ0y5ceL4wXQLcBudUq6yDKicV907usq7J+/lk0q0bp+dlb9LApTGdE6lrw5sY+SNY2ber7kK6o80za6T7OGlgycqM3uS8a+HxsT3yXLFBOc+ixjRXpO+Hnn1c83thZ2C3/HxHUivLHsBC4ylr3XLWLWtOV/vigjRTR93XtHZ3g/x+rzWH7hjy7laRsXyX5RmkSegbpctpDydNW/Wx/Pk9sKocwPGkvqaHkLpCHUy62cy3KHXpKO33HdJ386tIrRfHFrZdXXj8G4am39uc1FpWzPMo0m/Ry0m/uV8mDSg8l1KXPVKssGnF67cZhYtf4I+kfqLLkvp8Xk3uW0qpgqlunvPK4qb5Pio040KqDbyiS7qb8sPOi19shokYw11ZJH2R1Dy5BelLOYDDI+KLpXTnjXLsYU16Yzj+a0gf/m7Hr33ukg4hdZ7fnjTFxyOkAGPEKPPSMV5FCjjOioppRQpNycUm2isi4sWldOeRvmweyM+XJfWTLDd7Lt+rPDF03+8FSDUfF5KaCiEF2yPu6JHTP4s0+CpINb7d0m1MuvJdllRTsDTwrSjd/SSnPZbU//GUnO92DNXSEEPNxLXOqUlZB1HOnPZ3pC/+TnePHYBdImKLXufQi9KMAfsx1C3jQtK8t/ePck7LAN8snpOkj5KCpGtJNRV7RsQpeduIJluNvC0jwIOkC6ivRuFuKpJmkF6jqxg+fVS5yXnUO0BJOrXzsJDmNaTuEVV5ntajnD+KiP8U0r6YGndJk/QW4Kek4L5yGjZJPyNd9Cyez2cJ0oXDFjnP95XKVLusdctZt6xVJD0jutwRJ/+GlD0I3BIRT5TSfpz0ndjr9rKdtBuT3p9/YJRbIOf0Z0VErWnZuqWV9CTponvYd3x+vmpELNwkXU5b/M6eRvqtWYH0mZ/Z+Q4vdIkQqSVi5YiI/PzKGH7L1CuK+5Hm8Xy8nFaFO8iVu/QUy9Xl+cyI2ExpVovZEfH/Ctuui4i1u7y210fEc/PjYd2dlEbXH0aaWeSQ4vdI3TznFZ6+qY8i9eMZ0ZenwjqkTtPFH7lDi1/cAEpTxhwEvITUB+ki4OMRcWPFsTtTUpwoaXtSrUbV9CynM/y2leXHjY4vaWFSoHhRRDygNIXGb0iDNr5Zke79EXGu0tx3LyV1iv9xVcAYER/KD38o6SzSnUPmVJxT5xjl/pxVc9sBPJrLM1vSN0lfVAtUpHsQuLrQz+x1wCWSvpfL1/lxupx0H+P74en7//69cxrk6aYi9Z38TEQcT2r66aqij+T3JVX2kYyIS/PDR6iYCqrkBob3Pzwl/y1P01LrnJqUtVhOSZ+NiLv7UE5Ig76+T6rBCFIt5YjXofN/66bz/1Tqt3tSRLy6V/q8T53X/v2kAYGPSJoOnCBpekQcRKkvYHYmqbvIz/Pz7UlB152k2privc6PIdXMDeunWOGTwHMjTZPTzeqkWpbDGfpe2JhUS1TlRtJMBJ0LgHeRmpafB/yY9APZ8SPS+2O0ch5I+r7pdRvWF0XEejkQuZ00jc+Tkn5KqnkcT1nrlrNWWSUdAHw7Iu7NFw3HA08pTbu0U0T8obTLIaTWqTmk1/9FpIuMZST9bwyfHum/pBq+L1C4uKBiejvSRcgjpGbq0ebQpW4QOkraG4EtIuLv5Q1K94dvmg4KZc+B+e6SOt89S5bSkoPPMzr/n/y8/L9aJl9ULEDq1vV4l7QnSDqaVLt5sqSPkS6AXsPQd2PH45LWijQf6oak/xWR+tqXj3+mpN8AxzJ0X/rVSf1/zyomlLRMRDyY8zpP0ttIrSLlioPaec4TYh6olp3fFtKX0eGkgT2vJn0RHl+RbibpC7LT9+09lO6aQgpoyssjnccVef6c1Gfp26QfmL+Rrur3YWR/tTrH/xlp8uDTSHNCnpz3ORo4uke6k6rSlfLesNdSSlurP2dO+2zSF/LS+bwPJP1Il9Pt3GsppPsxhdGQpEFVP+py7ANIzSqr03v08Kh9JKnZX2qM79Em59SzrFQ3ud1MGu096q336NH0nF+DylvUVqQ9jNS89ZG8XEAayTrs/5nT/o7SiOEueZ5G9Wfw6c8fpb7KpB/Ms/L7bnZFnlVT5HRGf88trb+05rmPegco0g/xx0l9bjfI63rNajDi2Az11S6f8xU1y3kBozQhkwKzhfP75+HOe4j0mb52PGWtW84GZS32HT6PfNccUgA8qyL9SRRmZyBVWpxACi5nl9LeSP3+rKPeApk0UO5k0kXoiH6sTdOSWgHW77L/R5qmy89/SkV3FtJAr8cLzw+n+vaca5EGvBbXHVVaVsrrn0Vppgvqzy7QCU6vI3W/2jSvX5HUYlIu16gj7Kk5C0GTPOeVpfUCzI8LcE3NdaMO7MlfBD9lqM/n5qQavldR3Rn/Agrzh5JqmCqn5Kh5/M7gpGnAXQzNqSeGd8avla6U90zSleQsUn+g/5JqZc9j5Jx1jftz5nSV/S6bpKN6DtJuA9VuqlhG/NhTo48kNftL5efFoPWlpW1VA7CanFPPspJqlsrn/HjVuVPdV+xmegStpOCyzoCdmQyfMmch8gCmirSnkH5IjqDLdEc53UGkC6w35eXnpJrZpz9/pNqaDUr7TSPVVjxZ9RkDNik835ihAXtXlNIeSOpj/RJ6T990Mumi80e9zienXY00yv9gCrc4rEh3LYVb45J+EK/tUs6vAbszSh9VatyGlRQs30hqzv0o6aLhx6RgaJ/xlLVuORuU9drOe678XqP6MzYiYOysY2Qg2uT2sqPeApn0HbotaY7RZzP6ILlaaee1hZoDtvpxHGpeKMzvi5vm23G5pM0i9yOTtCkp2Co7U9JepNF2QWpOOqPTfy9SX6AZwJ6k5plPR8RsSf+OkU0+HSuRmwmy/+Z1Veocf4HczL0EqflwGeA+0mCl4h1B6qYr+gepKX8ugKR1gX2jYvqmnHZRhu5ssgip2e5pXZrJnszlerqZbAzNaf+QtDfpggDS4Il/VJ1QRDyny7mWXU+6U9ewPpLKt6OL1Ldrkxjqv3QwcIikk0j9pcpNvj8ive6XkJrO/xARn8jb3srQbfMan9NoZSWNXH0d6f3Z+V/e1OW1uJeRdw5ZlXTBFVQ3O94I/Cn3cfxXZ2WM7P+2HKkWvNOHbsm8rspJeRnNyyJiRuH5aUp9kD9eWLcTpbu2RGpW3EnprkhluwJHSeo0NT4M7Ko0JdzXS2k7/Zo3K2ZPqpEp+jU17wAVadqrd0jahu53X4LU3P9HSZ0uFGsCe+RyHlNKW7xLWjDUD7X8/+xcqHS9DWtEfFfSL/Pjf+T+xK8l1Qpd0qCsH6ooa6ece5X2r3rfjVpWUlP7Gfk75SxJB5HeV68hDSgpu1rSoaTvXEjfudfkvoWPl9I2ub1snVsg3xMRPbsMjTHt0yQdFhG79yvdWPKMHCUOupz5OPfWSdvvcuTuRbuRLirPjIg/F7btHRGVdwhsiwcrTSANDUJYiDSly9/z82eTRoOvU0p/U+Fp58v76ecxfKDBaqSamLtII4HX6FKGL5AmiD85r3oz8MuIKP/A1RpYpNRh/iOkGrfvkIKQG0k/jCdEnlOvbrrS8UfMW1m1Lq//NanmaFh/TuC2XNiPSpobES/K6c8DPhPpNqPPA37eCSjqpisce3lSE/8r87EvIM15WTVoYA9SU/ID+flypLudHFJKt09536KI2E/SXyLiBRX7vZ7UnL12YX2tTv5dzgnSIIdu51SnrJ3356053yujem7GT1I/aO15/PJ7StIupJGs55Hey68kXdiUgyZygPKfGH6f6kUi4tFSumuBbSL3m1a6bekZURiM0ITS/Lerkpr/Fszn8aCkLWPodokj0kbEI4X1W0W+9eGg5QDpBaSa9ndExGOj7IKkn0TEe0dL1w8a6pv+D1Jf/E+R+qafQZoa6PFyuqjZh71BGTYnBYLPI9WE30q6KDgyRg5AWoyh8QMAfyJ9Vv9Dqv0s/p93rjpe1fu5Zjm3IH0f/I7hge2IC7ImaUv79ZxPtWm6qZCnug8M7QyWWq1Jupz2cIYqHt4LPF3x0KTME8WB6ARSur9zV5Hv2d1l31pf3rkW42UR8fkeaTYkTWUBqVn+itL2Rl/KklbJ5f+H0sjy15Ka9C4ZS7pC+uNIV/3FWrklI2KHirSVX8odEXFMDhpeFBFPKI9iLOxfDD5rpRsL5dGcpXVXlAPBmnn9lHS3jHKAshtp8NtChXW1g9aK46wUNSdClvTM6DEISdK2pJkQpkfEs7qkqRW0joXS6P7OzRMuju4zEcwEXtv54c+1k2fHyAnttyT1Pb0Rnr7N4u4xfFBJ3bLVHl3fJG1eV3skfo1ylmvCROrrPmJ0fUVa6NNI/Jpl7TXCXhGxc410xDhG4vco2y4RcVSP7V1H1zdNqxqj8fP3yQtIA9Y6A7UiIv6nIr/aaUv71RqNXzfdVMhTLc4uMK9wIDoPavrlPYDjN/5SHlA5FiXVJHRq5S6gYnaBiv0qv5QlfYTUj++AnOdyDDWTrdkJ9Buka9z8kQOC9SJ/8HIecyLX8jbNU9ImpB+ASyWtQ5pn7i8RcUYpXa2gtctV9+WkJmAVa0TrplXqenJtRDwkaXFSreSGpH6tX4s8CrTitRo1aM3pziHVxj2Qny8H/CIi3pCfL0wayNB5zV+dj39Nt5rDLhcMI9bl9Z1aQUiv/ai1gl2OOZd0d7anR9eT5jw8qHyx0iRtTv9Nuo/Ef3lEFEfij1bOy0kXpcXR9cflPIlC15UmaXP6gxg5uv2hvO/SdS7GS/nNieoR9uWpeWql62dZJf09csuVunQbIjX571R6TSu7DpFa2qq6DnUurDYk9aOFwmh84H8j4mwVpicaTZO01puk6+gxa0BErN4kXX5eVfHwJeANjFLx0IqYBzqqehm+0HAA0gCO33hg0QSUqdtk7gcwdLeLGaSaqetJV44jXqv8Wv6SNJn9XFIT3e6U7tFcJx0NBgsV1n+L9MOxRV6OB74zljxJtYUzSTUwXyddqHyRFLB/oeLYmzA0ancd0uCK8sjMJgOLaqUl1Zp0BmwcRqrtfHku/0mlPDcl/YhDCpS+SZoE+ht0GcVO9cjzKwqPryTfhYTUX/XPpAnqz6HiRgY53Z8oDPoBNiJNUdbrPdp18vea7/Hao+ubpO32fqTLSPwa5aw9ur5J2ryt9kj8mmWtNcK+brqmZWX43ZSKy1zgscJ+tUfXN0lbSDfqaHzSiPF1ar6uTdLWGo1fN91Uy5MWZxeYV5bWC+Cl4p/S8Mt7AMdv/KXc5+NXBZfXURFcjuVLucsxd2majuGzAkwjBVknkQZKXdHjf/vB/CNwAmkk+4JjyTN/qS1ICtgeYiiAW6ziy65W0Eoa1HEWhVvWATd1OZdaaRn+g18OpmeXntcOWgv7XMbwEdHPZvjdUq4qPJ4FLFZ4fbv9gGxMmsf0QtKo/OtJc4F2tldN19R12rSa763ao+ubpM3bao/Eb1DeWqPrm6SlwUj8mmWsNcK+brqmZSVdyG/AyLsqTSd1fSrmVWt0fZO0VZ+B8jqGAtFrSYNX/8roAVaTtLVG2NdNNxXznN+X1gvgpcc/p8EXfZ+P2/hLuc/Hb1I70PhLucsxa72+xXRU3G6UFDD9CbhujOf+cN08GV7rd0Vp2+zya0H9oLXzvjuQNL1XrxqsUdPm7bvkx0cBMwr/z0tLaWsHrYX1W5IG/v2EVBNwC/CGwvY/A+vmx2cxVDu6KD3mVyQ1da6bl4VK266jz60W+bV8Vpdt5Xlia6fN62bk98BNeZlDCkaXAN45lvIW8t6G1MVi3GmBrfP/8ry83EK6NesSdLllco1jrkJqaod0Y4a3UwjKm6YbpazbFMtKmv7r5V32/3nh8UdI0zG9htR15aD8XtqPkbekrJ22sM8vgUM7709Sn8HjSRe4nVrccrDcK8BqkvaPVevHmm4q5lmx32H9TNc07UQv7iM6CdQZgDSAYzYaWNTnY9ceLFS3P2dOO6fbIYHnRcQiDdPVHixUl6T7gHfXyVPSxcCrI+JRSQtExFN5/TLAeTF8cMsVMXQbu6cf5+ezo7rvY60+mqOlzeU5iDRA7l5SX7Vb8/LRiLiykPZXpFHnR0k6CvhBRMxSmrHgZ1G4rV7pGCswNIXRzCjcQUjprin7MnTXnZeRaoJfROr68HMayn0ff0IKRjrTpt0YfRpU1U9qMBJ/XqAxjMSfSKo5En8M+W5O/dH1tdPm9L1G469KYdqzshi9X3hl2sI+tUbY1003FfOs2K+1mQDa4EDU5jlNgsucfnNqfClLuovUWfv+8iFJE7Cv0iRdTltrsFCDc7+c1HQ/ap6SFqn6kc5B2cqRpz/K62oFrU0GFjUdhCRpaVIT1TTgtqgYid8kaK0rv6Ybk2YI6LxHbgN+G3mA0xjyvCIiXqya06a1RQ1H17dFDUbit001R+L38Xg9R9c3TavSYE6lafqC9JqvQem2vlGYOq1J2sI+tUbY1003FfOs2K+1mQBaMcjqVi9exrpQc1DRKHnsUnpet5msbrp9aDBYqGaZ/9HvPHO+i3RZvwLD+3g2GVjUuD9ng/IuDaxPGiS00jjzumIA789yt4HazdMTueTPzpL58fT8vtpzUK/LeF5PWhyg2bCsEzqYkwbdssppadbfvsltfRvdArhm2Wulm4p5zu9L6wXw4qXJQs1BRTntQPvV0qDfZYM8/93vPBsev8nAosb9OVt6z1xfeLwM6UJjDml2gjEFueXznVcXGo6ub7GcrQ7QbFjWvg/mpObo+jGkHdNo/F7rxpD2KGqMsK+bbirmmdO2NhNA24tv8WmTzX6kDzcwan/Obrcu7ZcnIt1551FJN0TEQwAR8W9JT42ybze3DyDPJq4qNO9dKWlGDPXRLPd9a5K2TasUHn+HVNP2JtKtTX9EurtYU/fluRlXBc4EPhsR9wNIuiQiNhlXifvnLkkbRMRsgEjzjr4ROJLUR3aeEKmryHdzH+Hv5u4x8+rv0xHAX0gXjF8AfiWpc5e4X/TasYeV6NEdaBxpp0maFqmL0mIRcSlARPwt98UtanJb3yZpNyPdivQmUj9JpSKMmJu1brqpmCfAz0jTy81lqBm/St10TdO2Zl79oNt8rGFw2eRLud/+K2nxSLd93OjpA6d+jpUf+hwEfIU0ynQaQ19MS+ck/2yaZ5/tBhyUf2TuBS6S1Omjuds40rYpCo9nxNDArO+qyx25lG4ssA2pOfvp78kYun/9oqQ+sTNJ5/pHSdtGxA2k0fbzip1odp/7VkX9+9y3JsZ2r/vRnE7qQjG7vEHS+eNI2+Re9zuQutWczNCtikfcxW4Maev2S2zSf3Gq5QlwT0RU3cxmrOmapm2NByvZPKfhYKEjgKMi4o8V+fw8It49wHLWHixU2HY9qSZublR8+MaS5yDUGVg0lrSDImk9RgaNJ+Vtt5GaokUauLNW57VX4VZ4pfzOII0oHlaTEPn+9ZKujIj1C+lfTeon+17gkJhHBgGZjTaYU/n20ZL2jIiDRsmrSdpaI+zrppuKeRbVHWFfN13TtG1yjajNi2pf8UfErt0yGWQQmvOvnFYm0tRB91ZtI/0IXFUVhI4jz77LXQJqjVBvknYQJB0JrEdpZCqp5gfSwIql8uNjSAO07lG67/zsLtmu1qX5rHjcZSLPDBAR50l6G3Ai0PNHyGwiRcT5wPnl9ZJ2IXVz2khpur7/ybW7Ku1fDJqapL2MHiPsSRevTdJNxTyLdiGNsF+I6u+xpumapm2NA1Gb57QZXE6Az5Cayv7A8CvUA7vvYqPYLCLW6bYxIvZTYS7NiHgkr79TUrc5RM+U9PqIOLvL9m8A/4/UNN85zpxcA/HFMZ2F2cTq9Lf/IanGbE1SANUhUtBSnBu3dtrIUzlJ+jFwcuTp5yRtRaFfdt10UzHPko0j4vldto0lXdO0rXHTvNkEknQ26VaQlU2+1lzunvGdiLimy/aPAB+mwVyaSpPg/5Q0mvtxRvblNZvnjdLf/umbc+S0h5ICzVfmVRdEl3l7G6YddhOS8a6binnm9UcB3+r2PdY0XdO0bXKNqNnEWiUi1m27EFPMsaSBUndSPTJ1d9J94h+RNB04QdL03MdNlTmmPqUvoXtf3mWAz5FqN55Jqg26GzgFOCDGOFG+WZ81Gcz5F9LF10l5+08k/Tgivl+Rb5O0dUfYD2LU/mTJE9oftd8a14iaTSBJ3wTO7dHkaw3lAWCfYGQt8y15+9UR8cJC+iWBE4BrgNdE9e1NLwA2j3wHqortvyXdbOCYiLgzr3sWsDOwRUS8vj9nZzZ2TQZz5trTl0TEv/LzJYCLugzma5J2edII+1cyNML+y+UBO3XTTcU8c9pnl9fB0PdY03RN07bJNaJmE+t/gU9Jegw3+fbLaFOUjGUuzRuB8yWdSXVf3ukR8Y3iDjkg/YaknrfvM5soDfvbC3iy8PxJurcYjJq2M8IeeG9E7NmtHHXTTcU8c9rO4MaH+5Guadp5gQNRswkUEUuNnsoauiIPOjqN6ilKxjKX5k15WTgvZbdI+gypRvQuAEkrAe8jzYxgNtkcBVws6eT8/M2kyfvHmrbuCPtBjNqfLHnCvDNqvzVumjebYJKWA9YmTYoOQERc0F6JJrfcIb8sImJgNZP5f7gXsB2pjyik+46fSuojWu6TZzbPk7Qh8PL89MKIuGKsaSV9lNQCtCZwe3ET6fO5ZpN0UzHPom4j7CPiA2NJ1zRtmxyImk0gSbsBewKrkeaw3IzUt+o1bZbLhpO0ImmqrRcy/IJh1P+Thm57ajbfqzvCfhCj9idLnjltq6P227RA2wUwm8/sCWwM3BIRrwZeDDzQaokmOUmLStpD0iGSjuws48z2Z6SRwc8hzbd4M3BpzX09FZfZkM4I+xWAFUkj7D8yjnRTMU/II+wlTc/LF+gxar9GuqZpW+MaUbMJJOnSiNhY0mxg04h4rDyq25qR9CvSF/67gS+Tpki5drRBAqPkeVlEbKTCLUA7/7v8uPb8jGbzs7oj7Acxan+y5Jm3tTpqv00erGQ2sW6TtCzpXs/nSLofmKem0piEnhsR75C0XUQckwcuXTjOPB/Pf++QtA2pFqF4684m8zOazc/qjsbv66j9yZJn26P25wUORM0mUES8JT/cV9J5wDLAWS0WaSroBI0PSFoXuJOhAURj9VWlSes/CXwfWBr4eGH76cCSnSmhiiSdP85jm00ldUfj93vU/mTJs+1R+61z07zZBNLQ/G6V5rUviMkgDwA7EViP9MW/JPCliPhhqwUzM6D+aPx+jtqfLHnOK6P22+RA1GwCSboZWJ2R87rBPPgFMb+S9L1e2yPioxNVFjOb+toetd8mN82bTaxzmATzuk0mkj7Ra3sM3Q2piUWBdYBf5ufvIN0S9KIx5GVmNprOCPuTSJUUP5H044j4/hjTNU3bGteImk2gyTKv22SSBydtTJpMHuBNwCXAdQAR0Xg6JUkzgZdHugMTkhYiNatt1pdCm5kVtD1qv02uETWbWP+QtDfpKhXSVEPz3Lxuk8xqwIYR8TCApH2B30TEe8aR53KkAUqdPrtL5nVmZoPQ5kwArXIgajaxdiDN63YyQ/O67dBqiSa/lYD/Fp7/N68bjwNI97A/j/TF/Upg33HmaWbWTZszAbTKTfNmNqnlu4W8kxTci3T/919GxNfHme+zgE3z04sj4s5xFdTMrIc2ZwJokwNRswkgaUFgN1Iz8pkR8efCtr0j4qutFW4KyF+2r8hPLxjvl62khSLi8dK6FSLi3vHka2Zmw/le82YT40fAq4B/At+XVBzJ/dZ2ijT5SVpD0rIRcTlwCmnOvMdH2a1Xfq+WdBvpjkpnS5pe2Hz2+EprZmZlDkTNJsYmEfHuiPg/UnPvkpJOkrQI82Dn8clA0l7AH4CZeVL7s4CtgF+ONqVTD98E3hARKwCHkW7D2hkp7/+TmVmfebCS2cRYuPMgTwm0u6R9gN+TRmRbc+8lzfW5OHAzsGZE3JOnKLkYGMv8oQtHxNUAEXGCpGuBkyR9ljS4zMzM+sg1omYTY5akLYsr8vyWRwHTWynR5PdkRPwbeAD4N6nbA50588bo8TxIiZzX1cAWpBHza48jXzMzq+DBSmYTRNImpNt4XippHWBL4C+duyxZM5KOJtU0LwE8CjxBap5/DbBURLxzDHm+FrinfBs8ScsAH46I/cdbbjMzG+JA1GwC5Gb4rUjdYc4h9RM9D3gd8FsHOM1Jmka69WYAJwCbAO8G/g78YJw1o2ZmNgEciJpNAElzgQ2ARYA7gdUi4iFJi5HmqJynbrlmI0k6MyK2arscZmZTiQcrmU2MJyLiSeBRSTdExEMAEfFvSU+1XLZJSdLSwOcYmpv154Vth0TEh8aQ54bdNpEuJMzMrI8ciJpNjP9KWjwiHgU26qzMfQ8diI7NUcB1wInA/0h6G/DuiHgM2Kznnt1dSpoSqmqqpmXHmKeZmXXhpnmzCSBpkRwgldevAKwcEXNbKNakJml2RGxQeP4FYGtgW+CciOhWu9krz6uAt0TEdRXbbo2I1cdRZDMzK3GNqNkEqApC8/p7Ad82cmwWkbRARDwFEBH7S7oduICxz826L92ntfvIGPM0M7MuXCNqZpOSpG8CZ0fEuaX1WwLfj4hxz/sp6eWk0fhXRYRv8Wlm1mcORM1sypG0S0QcNYb9LomITfLj9wN7ACcDrwdOi4gD+ltSM7P5mwNRM5tyJP09ItYYw35XRMSL8+NLga0Ltw2dGREv6ndZzczmZ+4jamaTkqQ53TYBK40x2wUkLUfqJ6qIuAfSbUMlPTHGPM3MrAsHomY2Wa0EvAG4v7RewJ/HmOcywGU5j5C0ckTcIWlJqqd0MjOzcXAgamaT1enAkhExu7xB0vljyTAipnfZ9BTwlrHkaWZm3bmPqJmZmZm1ott8eWZmZmZmA+VA1MzMzMxa4UDUzCYlSSHpp4Xn0yTdI+n0hvncnG+12ivN0ZLePkqa90lapfD8cEnrNClLj7y3kjRL0jWSrpD0nbx+X0mf6scxKo55s6QTC8/fLunoQRzLzOZfDkTNbLL6F7CupMXy89cBt7dYnvcBTweiEbFbRFwz3kwlrQscDLwnItYBZgDXjzffmjbqVzBtZlbFgaiZTWZnANvkxzsAx3U2SFpe0q8lzZE0U9J6ef0zJJ0t6WpJh5OnZZI0XdJVhf0/JWnf8gElfUnSpZKuknSYkreTAsSfSZotaTFJ50uakffZQdLcvM83Cnk9Iml/SVfmMlbNf/oZYP+I+AtARDwZEYdWlOv9uVxXSjpR0uJ5/Tvyca+UdEFe90JJl+SyzpHU7Xao3wG+UHGsTSRdlGtn/yzp+Xn9+/Jrfk6uUf2wpE/kdDMlLZ/TrSXpLEmXSbpQ0gu6HN/MpjgHomY2mf0C2F7SosB6wMWFbfsBV0TEesDngWPz+n2AP0bEC0m372x6B6aDI2LjiFgXWAx4Y0ScAMwCdoyIDSLi353Eubn+G8BrgA2AjSW9OW/u3LFpfeAC4P0Vx1uXNLfpaE7K5VofuBbYNa//EvCGvH7bvO6DwEERsQEpgL6tS57HAxtKem5p/V+AV+S7UH0J+FqpvG8FNgb2Bx7N6S4CdsppDgM+EhEbAZ8CDqlxfmY2BXkeUTObtCJijqTppNrQM0qbXw68Laf7fa4JXRp4JSlQIiJ+I6k8If5oXi3pM8DiwPLA1cBpPdJvDJzfuUuTpJ/lMvwa+C9pPlRIwebrGpalaF1JXwWWBZYEfpvX/wk4WtLxwEl53UXAFyStRgpgr+uS55PAt4DPAWcW1i8DHJNrUgNYqLDtvIh4GHhY0oMMvTZzgfXyzQFeCvxKevoeAYuM4XzNbApwjaiZTXanAt+m0Cw/Rk8w/Dtx0XKCXPN6CPD2fN/5H1ela+DxGJrM+UmqKweuBjaqkdfRwIdzufbrlCsiPgjsDawOXCbpGRHxc1Lt6L+BMyS9pke+PyEFzqsX1n2FFHCuC7yJ4a/BY4XHTxWeP5XPbwHggVxz3Fn+X43zM7MpyIGomU12RwL7RcTc0voLgR0BJG0O3BsRD5GawN+d128FLJfT3wU8M9ecLgK8seJYnYDr3lyzVxxJ/zCwVMU+lwCvkrSCpAVJtbd/aHB+3wI+L+l5ucwLSPpgRbqlgDskLUQ+75x+rYi4OCK+BNwDrC5pTeDGiPgecAqpW0OliHgc+C7w8cLqZRgaGPa+BudC/h/cJOkduXyStH6TPMxs6nAgamaTWkTclgOqsn1Jo77nAAcAO+f1+wGvlHQ1qYn+7zmfx4EvkwLHc0j9IMvHeoBUC3oVqen70sLmo4EfdgYrFfa5A9gLOA+4ErgsIk5pcH5zgI8Bx0m6Nh97zYqkXyT1kf1Tqezf6gyUAv6cy/BO4CpJs0l9Oo+ltyMYXlv7TeDrkq5gbF28dgR2lXQlqcZ3uzHkYWZTgG/xaWZmZmatcI2omZmZmbXCgaiZmZmZtcKBqJmZmZm1woGomZmZmbXCgaiZmZmZtcKBqJmZmZm1woGomZmZmbXi/wNe1GpF2v7VRgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the distribution of classes\n", + "class_names = list(class_counter_dict.keys())\n", + "num_classes = list(class_counter_dict.values())\n", + "\n", + "plt.figure(figsize=(9,9))\n", + "plt.pie(num_classes, labels=class_names)\n", + "plt.title(\"Class Distribution Pie Chart\")\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(11,4))\n", + "plt.bar(class_names, num_classes)\n", + "plt.xticks(rotation=90)\n", + "plt.title(\"Class Distribution Bar Chart\")\n", + "plt.xlabel(\"Modulation Class Name\")\n", + "plt.ylabel(\"Counts\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "The above distribution of classes shows all OFDM signals appearing less frequently than the remaining modulations. This makes sense because OFDM signals are drawn from a random distribution of bandwidths that are inherently larger than the remaining signals, meaning fewer OFDM signals can fit into a wideband spectrum without overlapping. Additionally, the random bursty probability and durations of OFDM signals makes it less likely to occupy a wideband capture with many short-time bursts, while the remaining modulations experience this behavior at a higher probility." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the distribution of number of signals per sample\n", + "plt.figure(figsize=(11,8))\n", + "plt.hist(x=num_signals_per_sample, bins=np.arange(1,max(num_signals_per_sample)+1)-0.5)\n", + "plt.title(\"Distribution of Number of Signals Per Sample\\nTotal Number: {} - Average: {} - Max: {}\".format(\n", + " sum(num_signals_per_sample),\n", + " np.mean(np.asarray(num_signals_per_sample)),\n", + " max(num_signals_per_sample),\n", + "))\n", + "plt.xlabel(\"Number of Signal Bins\")\n", + "plt.ylabel(\"Counts\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "The above distribution of the number of signals per sample shows the most commonly seen sample has two signals present. The average is slightly around 4 signals per sample and the max is 26." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Existing data found, skipping data generation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 250000/250000 [1:09:33<00:00, 59.91it/s]\n" + ] + } + ], + "source": [ + "# For additional analysis, reinstantiate the dataset without a target transform, such that the RFDescriptions can be read\n", + "wideband_sig53 = WidebandSig53(\n", + " root=root, \n", + " train=train, \n", + " impaired=impaired,\n", + " transform=None,\n", + " target_transform=None,\n", + ")\n", + "\n", + "num_samples = len(wideband_sig53)\n", + "snrs = []\n", + "bandwidths = []\n", + "durations = []\n", + "for idx in tqdm(range(num_samples)):\n", + " label = wideband_sig53[idx][1]\n", + " for rf_desc in label:\n", + " snrs.append(rf_desc.snr)\n", + " bandwidths.append(rf_desc.bandwidth)\n", + " durations.append(rf_desc.duration)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the distribution of SNR values\n", + "plt.figure(figsize=(11,4))\n", + "plt.hist(x=snrs, bins=100)\n", + "plt.title(\"SNR Distribution\")\n", + "plt.xlabel(\"SNR Bins (dB)\")\n", + "plt.ylabel(\"Counts\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the distribution of bandwidth values\n", + "plt.figure(figsize=(11,4))\n", + "plt.hist(x=bandwidths, bins=100)\n", + "plt.title(\"Bandwidth Distribution\")\n", + "plt.xlabel(\"BW Bins\")\n", + "plt.ylabel(\"Counts\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq4AAAEWCAYAAACnjhWDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAjtklEQVR4nO3de7hlVXnn++/PqnBR5CYVohSmSFumg7QaLQFzVTFYaGJxPAShNRQe2npyRE+MRkHNCbaXbshFWjqKp5QKYFRA2pYygpU6KNpJp5DCCwio7EaQQi4lV+9Y5O0/1ti62Ky9a9Vlrb3n5vt5nv3sOd8x5phj7lm1662xxhwzVYUkSZI01z1mtjsgSZIkDcPEVZIkSZ1g4ipJkqROMHGVJElSJ5i4SpIkqRNMXCVJktQJJq6SNEJJLkuycpbO/Yok/7gT27suyfPa9tuT/P1ObPutST60s9qTND/FdVwlzUdJbgb2B7YADwHXA+cDq6vqX0d0zrcDT6mqV46i/SnnOhf498BPWugW4FPA6VV1/3a0tamq/nwbjnk723mtLfn9+6pavK3HSnp0c8RV0nz2B1X1eOCXgdOBU4BztqehJAt3Zsd2kr9s17cIeBVwOPDPSR63M08yR69d0qOQiaukea+q7q+qtcDLgZVJDgFIckWS/zBZL8mJSf6pb7+SnJzkRuDGFntvkluTPJDk6iS/3eLLgbcCL0/y/SRfnXqOJI9J8udJbklyV5Lzk+zVypa0861M8u0k303ytiGv78dVdRXwUuAJ9JLYh11Pes5s530gybVJDkmyCngF8ObW70+1+jcnOSXJNcAPkixssRf2nXq3JBcm+V6SLyV5xpSf3VP69s9N8q6WVF8GPKmd7/tJnjR16kGSl7apCfe1n+Gv9ZXdnOTPklyT5P7Wh92G+VlJ6jYTV0mPGlX1RWAT8NvbcNjRwGHAwW3/KuCZwL7AR4GPJ9mtqj4D/Cfgwqrao6qeMaCtE9vX84FfAfYA/nZKnd8CfhU4AviL/oRta6rqe8B6Bl/fkcDvAE8F9gKOBe6uqtXAR+iN3u5RVX/Qd8zxwEuAvatqy4A2VwAf5+c/i08m+YWt9PEHwFHAd9r59qiq7/TXSfJU4GPA6+mNJl8KfCrJLn3VjgWWAwcBT6f3c5U0z5m4Snq0+Q69RGtY/7mq7qmqHwFU1d9X1d1VtaWq/gbYlV6iOYxXAO+pqpuq6vvAW4DjpnwU/x+r6kdV9VXgq8CgBHgm013fT4HHA/+W3vMNN1TV7Vtp66yqunXy2ge4uqourqqfAu8BdqM3XWFHvRz4dFWtb23/NbA78BtT+vadqrqH3tzeZ+6E80qa40xcJT3aHADcsw31b+3faR9R39A+or6P3ujlfkO29SR6D1FNugVYSO8hskl39G3/kN6o7LYYeH1V9Vl6o7vvA+5KsjrJnltp69Zhy9sDb5voXeOOetjPqbV9K71rm7SjPydJHWTiKulRI8lz6CU/k/NYfwA8tq/KLw047GdLr7T5rG+m9zH1PlW1N3A/kKl1p/Edeg+KTXoyvVUP7hzuCmaWZA/ghcD/GFReVWdV1bPpTXt4KvCmyaJpmtza9RzYd+7HAIvpXSP0ksnpfrbb9HNKknau27ZynKR5zsRV0ryXZM8kvw9cQG8Zpmtb0VeAlyV5bHuQ6KStNPV4eonmZmBhkr8A+kct7wSWtCRukI8Bf5rkoJZkTs6JHTR/dGhJdk3ybOCTwL3A3w2o85wkh7U5qD8AfgxMLgt2J705t9vq2Ule1qY6vJ7e0lwbWtlXgH+fZEF7cO13+467E3jC5INpA1wEvCTJEa2/b2xt/8/t6KOkecTEVdJ89qkk36P3MfPb6M3DfFVf+ZnAg/QSqfPoPaQ0k3XAZ4Bv0vso+8c8/OP0j7fvdyf50oDj1wAfBr4AfKsd/7ptuJ6p3tyu7256a9ReDfxGewBqqj2BD9JLbG9px/xVKzsHOLg9wf/JbTj/JfTmo94L/BHwsjYnFeBPgD8A7qM3t/dn7VbV1+kl8Te1cz5sekFVfQN4JfBfge+2dv6gqh7chr5Jmod8AYEkSZI6wRFXSZIkdYKJqyRJkjrBxFWSJEmdYOIqSZKkTli49SqPDvvtt18tWbJktrshSZL0qHf11Vd/t6oWTY2buDZLlixh48aNs90NSZKkR70ktwyKO1VAkiRJnWDiKkmSpE4wcZUkSVInmLhKkiSpE0xcJUmS1AkmrpIkSeoEE1dJkiR1gomrJEmSOsHEVZIkSZ3gm7MkSZIEwJJTPz0wfvPpLxlzTwZzxFWSJEmdYOIqSZKkTjBxlSRJUieYuEqSJKkTTFwlSZLUCSaukiRJ6gQTV0mSJHWCiaskSZI6wcRVkiRJnTCyxDXJmiR3JfnalPjrknw9yXVJ/rIv/pYkE0m+keRFffHlLTaR5NS++EFJrmzxC5Ps0uK7tv2JVr5kVNcoSZKk8RnliOu5wPL+QJLnAyuAZ1TV04C/bvGDgeOAp7Vj3p9kQZIFwPuAo4CDgeNbXYAzgDOr6inAvcBJLX4ScG+Ln9nqSZIkqeNGlrhW1ReAe6aE/2/g9Kr6SatzV4uvAC6oqp9U1beACeDQ9jVRVTdV1YPABcCKJAFeAFzcjj8POLqvrfPa9sXAEa2+JEmSOmzcc1yfCvx2+wj/80me0+IHALf21dvUYtPFnwDcV1VbpsQf1lYrv7/Vf4Qkq5JsTLJx8+bNO3xxkiRJGp1xJ64LgX2Bw4E3ARfN5mhoVa2uqmVVtWzRokWz1Q1JkiQNYdyJ6ybgE9XzReBfgf2A24AD++otbrHp4ncDeydZOCVO/zGtfK9WX5IkSR027sT1k8DzAZI8FdgF+C6wFjiurQhwELAU+CJwFbC0rSCwC70HuNZWVQGfA45p7a4ELmnba9s+rfyzrb4kSZI6bOHWq2yfJB8Dngfsl2QTcBqwBljTlsh6EFjZksrrklwEXA9sAU6uqodaO68F1gELgDVVdV07xSnABUneBXwZOKfFzwE+nGSC3sNhx43qGiVJkjQ+I0tcq+r4aYpeOU39dwPvHhC/FLh0QPwmeqsOTI3/GPjDbeqsJEmS5jzfnCVJkqROMHGVJElSJ5i4SpIkqRNMXCVJktQJJq6SJEnqBBNXSZIkdYKJqyRJkjrBxFWSJEmdYOIqSZKkTjBxlSRJUieYuEqSJKkTTFwlSZLUCSaukiRJ6gQTV0mSJHWCiaskSZI6YWSJa5I1Se5K8rUBZW9MUkn2a/tJclaSiSTXJHlWX92VSW5sXyv74s9Ocm075qwkafF9k6xv9dcn2WdU1yhJkqTxGeWI67nA8qnBJAcCRwLf7gsfBSxtX6uAs1vdfYHTgMOAQ4HT+hLRs4FX9x03ea5TgcurailweduXJElSx40sca2qLwD3DCg6E3gzUH2xFcD51bMB2DvJE4EXAeur6p6quhdYDyxvZXtW1YaqKuB84Oi+ts5r2+f1xSVJktRhY53jmmQFcFtVfXVK0QHArX37m1pspvimAXGA/avq9rZ9B7D/zum9JEmSZtPCcZ0oyWOBt9KbJjAWVVVJarryJKvoTU3gyU9+8ri6JUmSpO0wzhHXfwMcBHw1yc3AYuBLSX4JuA04sK/u4habKb54QBzgzjaVgPb9ruk6VFWrq2pZVS1btGjRDlyaJEmSRm1siWtVXVtVv1hVS6pqCb2P959VVXcAa4ET2uoChwP3t4/71wFHJtmnPZR1JLCulT2Q5PC2msAJwCXtVGuBydUHVvbFJUmS1GGjXA7rY8C/AL+aZFOSk2aofilwEzABfBB4DUBV3QO8E7iqfb2jxWh1PtSO+V/AZS1+OvB7SW4EXtj2JUmS1HEjm+NaVcdvpXxJ33YBJ09Tbw2wZkB8I3DIgPjdwBHb2F1JkiTNcb45S5IkSZ1g4ipJkqROMHGVJElSJ5i4SpIkqRNMXCVJktQJJq6SJEnqBBNXSZIkdYKJqyRJkjrBxFWSJEmdYOIqSZKkTjBxlSRJUieYuEqSJKkTTFwlSZLUCSaukiRJ6gQTV0mSJHWCiaskSZI6YWSJa5I1Se5K8rW+2F8l+XqSa5L89yR795W9JclEkm8keVFffHmLTSQ5tS9+UJIrW/zCJLu0+K5tf6KVLxnVNUqSJGl8Rjniei6wfEpsPXBIVT0d+CbwFoAkBwPHAU9rx7w/yYIkC4D3AUcBBwPHt7oAZwBnVtVTgHuBk1r8JODeFj+z1ZMkSVLHjSxxraovAPdMif1jVW1puxuAxW17BXBBVf2kqr4FTACHtq+Jqrqpqh4ELgBWJAnwAuDidvx5wNF9bZ3Xti8Gjmj1JUmS1GGzOcf1/wIua9sHALf2lW1qseniTwDu60uCJ+MPa6uV39/qP0KSVUk2Jtm4efPmHb4gSZIkjc6sJK5J3gZsAT4yG+efVFWrq2pZVS1btGjRbHZFkiRJW7Fw3CdMciLw+8ARVVUtfBtwYF+1xS3GNPG7gb2TLGyjqv31J9valGQhsFerL0mSpA4b64hrkuXAm4GXVtUP+4rWAse1FQEOApYCXwSuApa2FQR2ofcA19qW8H4OOKYdvxK4pK+tlW37GOCzfQmyJEmSOmpkI65JPgY8D9gvySbgNHqrCOwKrG/PS22oqj+uquuSXARcT28KwclV9VBr57XAOmABsKaqrmunOAW4IMm7gC8D57T4OcCHk0zQezjsuFFdoyRJksZnZIlrVR0/IHzOgNhk/XcD7x4QvxS4dED8JnqrDkyN/xj4w23qrCRJkuY835wlSZKkTjBxlSRJUieYuEqSJKkTTFwlSZLUCSaukiRJ6gQTV0mSJHWCiaskSZI6wcRVkiRJnWDiKkmSpE4wcZUkSVInmLhKkiSpE0xcJUmS1AkmrpIkSeoEE1dJkiR1gomrJEmSOmGbE9ck+yR5+hD11iS5K8nX+mL7Jlmf5Mb2fZ8WT5KzkkwkuSbJs/qOWdnq35hkZV/82UmubceclSQznUOSJEndNlTimuSKJHsm2Rf4EvDBJO/ZymHnAsunxE4FLq+qpcDlbR/gKGBp+1oFnN3Ouy9wGnAYcChwWl8iejbw6r7jlm/lHJIkSeqwYUdc96qqB4CXAedX1WHAC2c6oKq+ANwzJbwCOK9tnwcc3Rc/v3o2AHsneSLwImB9Vd1TVfcC64HlrWzPqtpQVQWcP6WtQeeQJElShw2buC5syeKxwD/swPn2r6rb2/YdwP5t+wDg1r56m1pspvimAfGZzvEISVYl2Zhk4+bNm7fjciRJkjQuwyau/xFYB0xU1VVJfgW4cUdO3EZKa0fa2NFzVNXqqlpWVcsWLVo0yq5IkiRpBw2buN5eVU+vqtcAVNVNwNbmuA5yZxu5pX2/q8VvAw7sq7e4xWaKLx4Qn+kckiRJ6rBhE9f/OmRsa9YCkysDrAQu6Yuf0FYXOBy4v33cvw44sq1ksA9wJLCulT2Q5PC2msAJU9oadA5JkiR12MKZCpM8F/gNYFGSN/QV7Qks2MqxHwOeB+yXZBO91QFOBy5KchJwC705swCXAi8GJoAfAq8CqKp7krwTuKrVe0dVTT7w9Rp6KxfsDlzWvpjhHJIkSeqwGRNXYBdgj1bv8X3xB4BjZjqwqo6fpuiIAXULOHmadtYAawbENwKHDIjfPegckiRJ6rYZE9eq+jzw+STnVtUtY+qTJEmS9AhbG3GdtGuS1cCS/mOq6gWj6JQkSZI01bCJ68eBDwAfAh4aXXckSZKkwYZNXLdU1dkj7YkkSZI0g2GXw/pUktckeWKSfSe/RtozSZIkqc+wI66T66K+qS9WwK/s3O5IkiRJgw2VuFbVQaPuiCRJkjSToRLXJCcMilfV+Tu3O5IkSdJgw04VeE7f9m70Fvj/EmDiKkmSpLEYdqrA6/r3k+wNXDCKDkmSJEmDDLuqwFQ/AJz3KkmSpLEZdo7rp+itIgCwAPg14KJRdUqSJEmaatg5rn/dt70FuKWqNo2gP5IkSdJAQ00VqKrPA18HHg/sAzw4yk5JkiRJUw2VuCY5Fvgi8IfAscCVSY4ZZcckSZKkfsM+nPU24DlVtbKqTgAOBf7f7T1pkj9Ncl2SryX5WJLdkhyU5MokE0kuTLJLq7tr259o5Uv62nlLi38jyYv64stbbCLJqdvbT0mSJM0dwyauj6mqu/r2796GYx8myQHA/wMsq6pD6D3sdRxwBnBmVT0FuBc4qR1yEnBvi5/Z6pHk4Hbc04DlwPuTLEiyAHgfcBRwMHB8qytJkqQOGzb5/EySdUlOTHIi8Gng0h0470Jg9yQLgccCtwMvAC5u5ecBR7ftFW2fVn5EkrT4BVX1k6r6FjBBbyT4UGCiqm6qqgfprTe7Ygf6KkmSpDlgxlUFkjwF2L+q3pTkZcBvtaJ/AT6yPSesqtuS/DXwbeBHwD8CVwP3VdWWVm0TcEDbPgC4tR27Jcn9wBNafENf0/3H3Dolftg017cKWAXw5Cc/eXsuR5IkSWOytRHX/wI8AFBVn6iqN1TVG4D/3sq2WZJ96I2AHgQ8CXgcvY/6x66qVlfVsqpatmjRotnogiRJkoa0tcR1/6q6dmqwxZZs5zlfCHyrqjZX1U+BTwC/Cezdpg4ALAZua9u3AQcCtPK96M2x/Vl8yjHTxSVJktRhW0tc956hbPftPOe3gcOTPLbNVT0CuB74HDC5xNZK4JK2vbbt08o/W1XV4se1VQcOApbSW7LrKmBpW6VgF3oPcK3dzr5KkiRpjtha4roxyaunBpP8B3rzUrdZVV1J7yGrLwHXtj6sBk4B3pBkgt4c1nPaIecAT2jxNwCntnauo/fa2euBzwAnV9VDbZ7sa4F1wA3ARa2uJEmSOiy9wctpCpP96c1nfZCfJ6rLgF2A/6Oq7hh5D8dk2bJltXHjxtnuhiRJ0qxZcuqnB8ZvPv0lY+1HkquratnU+IyrClTVncBvJHk+cEgLf7qqPjuCPkqSJEnTmjFxnVRVn6M3B1WSJEmaFdv19itJkiRp3ExcJUmS1AkmrpIkSeoEE1dJkiR1gomrJEmSOsHEVZIkSZ1g4ipJkqROMHGVJElSJ5i4SpIkqRNMXCVJktQJJq6SJEnqBBNXSZIkdYKJqyRJkjphVhLXJHsnuTjJ15PckOS5SfZNsj7Jje37Pq1ukpyVZCLJNUme1dfOylb/xiQr++LPTnJtO+asJJmN65QkSdLOM1sjru8FPlNV/xZ4BnADcCpweVUtBS5v+wBHAUvb1yrgbIAk+wKnAYcBhwKnTSa7rc6r+45bPoZrkiRJ0ggtHPcJk+wF/A5wIkBVPQg8mGQF8LxW7TzgCuAUYAVwflUVsKGN1j6x1V1fVfe0dtcDy5NcAexZVRta/HzgaOCy0V/d3LXk1E8/Inbz6S+ZhZ5IkiRtn9kYcT0I2Az8XZIvJ/lQkscB+1fV7a3OHcD+bfsA4Na+4ze12EzxTQPij5BkVZKNSTZu3rx5By9LkiRJozQbietC4FnA2VX168AP+Pm0AADa6GqNuiNVtbqqllXVskWLFo36dJIkSdoBs5G4bgI2VdWVbf9ieonsnW0KAO37Xa38NuDAvuMXt9hM8cUD4pIkSeqwsSeuVXUHcGuSX22hI4DrgbXA5MoAK4FL2vZa4IS2usDhwP1tSsE64Mgk+7SHso4E1rWyB5Ic3lYTOKGvLUmSJHXU2B/Oal4HfCTJLsBNwKvoJdEXJTkJuAU4ttW9FHgxMAH8sNWlqu5J8k7gqlbvHZMPagGvAc4Fdqf3UNaj+sEsSZKk+WBWEteq+gqwbEDREQPqFnDyNO2sAdYMiG8EDtmxXs5/g1YaAFcbkCRJc5NvzpIkSVInmLhKkiSpE0xcJUmS1AkmrpIkSeoEE1dJkiR1gomrJEmSOsHEVZIkSZ1g4ipJkqROMHGVJElSJ8zWK181hw16o5Zv05IkSbPNEVdJkiR1gomrJEmSOsHEVZIkSZ1g4ipJkqROMHGVJElSJ8xa4ppkQZIvJ/mHtn9QkiuTTCS5MMkuLb5r259o5Uv62nhLi38jyYv64stbbCLJqWO/OEmSJO10s7kc1p8ANwB7tv0zgDOr6oIkHwBOAs5u3++tqqckOa7Ve3mSg4HjgKcBTwL+/yRPbW29D/g9YBNwVZK1VXX9uC5sPhq0RBa4TJYkSRqfWRlxTbIYeAnwobYf4AXAxa3KecDRbXtF26eVH9HqrwAuqKqfVNW3gAng0PY1UVU3VdWDwAWtriRJkjpstqYK/BfgzcC/tv0nAPdV1Za2vwk4oG0fANwK0Mrvb/V/Fp9yzHTxR0iyKsnGJBs3b968g5ckSZKkURp74prk94G7qurqcZ97qqpaXVXLqmrZokWLZrs7kiRJmsFszHH9TeClSV4M7EZvjut7gb2TLGyjqouB21r924ADgU1JFgJ7AXf3xSf1HzNdXJIkSR019hHXqnpLVS2uqiX0Hq76bFW9AvgccEyrthK4pG2vbfu08s9WVbX4cW3VgYOApcAXgauApW2Vgl3aOdaO4dIkSZI0QrO5qsBUpwAXJHkX8GXgnBY/B/hwkgngHnqJKFV1XZKLgOuBLcDJVfUQQJLXAuuABcCaqrpurFfyKOJqA5IkaVxmNXGtqiuAK9r2TfRWBJha58fAH05z/LuBdw+IXwpcuhO7KkmSpFnmm7MkSZLUCXNpqoDmkUFTCJw+IEmSdoQjrpIkSeoEE1dJkiR1gomrJEmSOsHEVZIkSZ3gw1kaG9d8lSRJO8IRV0mSJHWCiaskSZI6wakCmnWu+SpJkobhiKskSZI6wRFXzUk+yCVJkqZyxFWSJEmdYOIqSZKkTnCqgDrFKQSSJD16jT1xTXIgcD6wP1DA6qp6b5J9gQuBJcDNwLFVdW+SAO8FXgz8EDixqr7U2loJ/Hlr+l1VdV6LPxs4F9gduBT4k6qqsVygZoUrE0iSNP/NxlSBLcAbq+pg4HDg5CQHA6cCl1fVUuDytg9wFLC0fa0CzgZoie5pwGHAocBpSfZpx5wNvLrvuOVjuC5JkiSN0NhHXKvqduD2tv29JDcABwArgOe1aucBVwCntPj5bcR0Q5K9kzyx1V1fVfcAJFkPLE9yBbBnVW1o8fOBo4HLxnB5mkOcViBJ0vwyqw9nJVkC/DpwJbB/S2oB7qA3lQB6Se2tfYdtarGZ4psGxCVJktRhs5a4JtkD+G/A66vqgf6yNro68jmpSVYl2Zhk4+bNm0d9OkmSJO2AWVlVIMkv0EtaP1JVn2jhO5M8sapub1MB7mrx24AD+w5f3GK38fOpBZPxK1p88YD6j1BVq4HVAMuWLfPhrUcJH+SSJKmbxj7i2lYJOAe4oare01e0FljZtlcCl/TFT0jP4cD9bUrBOuDIJPu0h7KOBNa1sgeSHN7OdUJfW5IkSeqo2Rhx/U3gj4Brk3ylxd4KnA5clOQk4Bbg2FZ2Kb2lsCboLYf1KoCquifJO4GrWr13TD6oBbyGny+HdRk+mKWt8EEuSZLmvtlYVeCfgExTfMSA+gWcPE1ba4A1A+IbgUN2oJuSJEmaY3xzljQD58NKkjR3zOpyWJIkSdKwTFwlSZLUCSaukiRJ6gQTV0mSJHWCiaskSZI6wcRVkiRJnWDiKkmSpE4wcZUkSVInmLhKkiSpE0xcJUmS1Am+8nWeGfSKUkmSpPnAEVdJkiR1gomrJEmSOsGpApIkaeTmy1S2m09/yVjPN93Pbdz9mCtMXKVt5C8RzWXzJTl4NJrud8i2/M4Z5f33d1zPXP87Ntf7t6NSVbPdh5FIshx4L7AA+FBVnT5T/WXLltXGjRvH0rdRmu9/YOc7/2GYW0b5n5RBbY+qXUnaUeP+9ynJ1VW17BHx+Zi4JlkAfBP4PWATcBVwfFVdP90x405c/cdFkiR1xVxJXOfrw1mHAhNVdVNVPQhcAKyY5T5JkiRpB8zXOa4HALf27W8CDptaKckqYFXb/X6Sb4yhb5P2A747xvNp5/HedZv3r9u8f93lveuwnDH2+/fLg4LzNXEdSlWtBlbPxrmTbBw0BK65z3vXbd6/bvP+dZf3rtvmyv2br1MFbgMO7Ntf3GKSJEnqqPmauF4FLE1yUJJdgOOAtbPcJ0mSJO2AeTlVoKq2JHktsI7eclhrquq6We7WVLMyRUE7hfeu27x/3eb96y7vXbfNifs3L5fDkiRJ0vwzX6cKSJIkaZ4xcZUkSVInmLiOWJLlSb6RZCLJqQPKd01yYSu/MsmSWeimBhji3r0hyfVJrklyeZKBa85pdmzt/vXV+z+TVJJZX+ZFPcPcuyTHtr9/1yX56Lj7qOkN8bvzyUk+l+TL7ffni2ejn3qkJGuS3JXka9OUJ8lZ7d5ek+RZ4+6jiesItVfPvg84CjgYOD7JwVOqnQTcW1VPAc4EzhhvLzXIkPfuy8Cyqno6cDHwl+PtpaYz5P0jyeOBPwGuHG8PNZ1h7l2SpcBbgN+sqqcBrx93PzXYkH/3/hy4qKp+nd6qP+8fby81g3OB5TOUHwUsbV+rgLPH0KeHMXEdrWFePbsCOK9tXwwckSRj7KMG2+q9q6rPVdUP2+4GeusFa24Y9rXP76T3n8Ufj7NzmtEw9+7VwPuq6l6AqrprzH3U9Ia5fwXs2bb3Ar4zxv5pBlX1BeCeGaqsAM6vng3A3kmeOJ7e9Zi4jtagV88eMF2dqtoC3A88YSy900yGuXf9TgIuG2mPtC22ev/aR1wHVtWnx9kxbdUwf/eeCjw1yT8n2ZBkphEijdcw9+/twCuTbAIuBV43nq5pJ9jWfxt3unm5jqs0TkleCSwDfne2+6LhJHkM8B7gxFnuirbPQnofVT6P3icdX0jy76rqvtnslIZ2PHBuVf1NkucCH05ySFX962x3THOfI66jNcyrZ39WJ8lCeh+b3D2W3mkmQ702OMkLgbcBL62qn4ypb9q6rd2/xwOHAFckuRk4HFjrA1pzwjB/9zYBa6vqp1X1LeCb9BJZzb5h7t9JwEUAVfUvwG7AfmPpnXbUUP82jpKJ62gN8+rZtcDKtn0M8NnyrRBzwVbvXZJfB/4/ekmrc+zmlhnvX1XdX1X7VdWSqlpCb47yS6tq4+x0V32G+b35SXqjrSTZj97UgZvG2EdNb5j7923gCIAkv0Yvcd081l5qe60FTmirCxwO3F9Vt4+zA04VGKHpXj2b5B3AxqpaC5xD72OSCXoToo+bvR5r0pD37q+APYCPt+fpvl1VL521Tutnhrx/moOGvHfrgCOTXA88BLypqvykag4Y8v69Efhgkj+l96DWiQ7YzA1JPkbvP4X7tTnIpwG/AFBVH6A3J/nFwATwQ+BVY++jf1YkSZLUBU4VkCRJUieYuEqSJKkTTFwlSZLUCSaukiRJ6gQTV0mSJHWCiask7SRJHkrylSTXJflqkje2t3TtrPZPTPKkvv0PJTl4J7W7ua/vFyd5bCv74yQn7Og5JGlncDksSdpJkny/qvZo278IfBT456o6bRvaWFBVD01TdgXwZzv7RQlJTgSWVdVr2/5HgfVV9Xc78zyStKMccZWkEWhvU1sFvLa9ZebEJH87WZ7kH5I8r21/P8nfJPkq8Nwkf5HkqiRfS7K6HX8MsAz4SBsZ3T3JFZOvqU1yfJJr2zFn9J3n+0ne3UaANyTZf6Z+t1dPPw64t+2/Pcmfte0rkpyR5ItJvpnkt1v8aS32lSTXJPH1q5JGwsRVkkakqm6i9/agX9xK1ccBV1bVM6rqn4C/rarnVNUhwO7A71fVxcBG4BVV9cyq+tHkwW36wBnAC4BnAs9JcnRf2xuq6hnAF4BXT9OHlyf5Cr33ju8LfGqaegur6lDg9fTeqgPwx8B7q+qZ9JLrTVu5XknaLiaukjT7HgL+W9/+85NcmeRaesno07Zy/HOAK6pqc1VtAT4C/E4rexD4h7Z9NbBkmjYubInnLwHXAm+apt4nBrT1L8Bbk5wC/HJ/Ui1JO5OJqySNSJJfoZeU3gVs4eG/c3fr2/7x5LzWJLsB7weOqap/B3xwSt1t9dO+98A/BCycqXKr+yl+nvhO9ZOpbVXVR4GXAj8CLk3ygh3oryRNy8RVkkYgySLgA/Q+9i/gZuCZSR6T5EDg0GkOnUxSv5tkD+CYvrLvAY8fcMwXgd9Nsl+SBcDxwOd3oPu/BfyvYSu3BP2mqjoLuAR4+g6cW5KmNeP/vCVJ22T3Nk/0F+iNsH4YeE8r+2fgW8D1wA3AlwY1UFX3Jfkg8DXgDuCqvuJzgQ8k+RHw3L5jbk9yKvA5IMCnq+qSbez7y5P8Fr0BjU3Aidtw7LHAHyX5aevzf9rGc0vSUFwOS5IkSZ3gVAFJkiR1gomrJEmSOsHEVZIkSZ1g4ipJkqROMHGVJElSJ5i4SpIkqRNMXCVJktQJ/xukkDh0olDtxQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the distribution of bandwidth values\n", + "plt.figure(figsize=(11,4))\n", + "plt.hist(x=durations, bins=100)\n", + "plt.title(\"Duration Distribution\")\n", + "plt.xlabel(\"Duration Bins\")\n", + "plt.ylabel(\"Counts\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/04_example_wideband_modulations_dataset.ipynb b/examples/04_example_wideband_modulations_dataset.ipynb new file mode 100644 index 0000000..e651ab1 --- /dev/null +++ b/examples/04_example_wideband_modulations_dataset.ipynb @@ -0,0 +1,192 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example 04 - Wideband Modulations Dataset\n", + "This notebook steps through an example of how to use `torchsig` to instantiate a custom, online `WidebandDataset` containing signals with up to 53 unique classes of modulations. The notebook then plots the signals using `Visualizers` for the Spectrogram representations of the dataset. \n", + "\n", + "-------------------------------------------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from torch.utils.data import DataLoader\n", + "\n", + "import torchsig.transforms as ST\n", + "from torchsig.datasets import WidebandModulationsDataset\n", + "from torchsig.utils.visualize import MaskClassVisualizer, mask_class_to_outline, complex_spectrogram_to_magnitude" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "----------------------------------\n", + "### Define Dataset Parameters & Transforms\n", + "The `WidebandModulationsDataset` inputs a list of modulations to include, and it also inputs the data and target transforms. Below's example includes the full list of all supported modulations, but a subset of this list can be selected to create an easier, more specialized task. The data transforms below are strictly the IQ to spectrogram transformation with a renormalization; however, these can be replaced with a custom composition of augmentations for tailored experiments. The target transform in this example transforms the `SignalDescription` for each example into a set of masks for each class." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "modulation_list = [\n", + " \"ook\",\"bpsk\",\"4pam\",\"4ask\",\"qpsk\",\"8pam\",\"8ask\",\"8psk\",\"16qam\",\"16pam\",\n", + " \"16ask\",\"16psk\",\"32qam\",\"32qam_cross\",\"32pam\",\"32ask\",\"32psk\",\"64qam\",\"64pam\",\"64ask\",\n", + " \"64psk\",\"128qam_cross\",\"256qam\",\"512qam_cross\",\"1024qam\",\"2fsk\",\"2gfsk\",\"2msk\",\"2gmsk\",\"4fsk\",\n", + " \"4gfsk\",\"4msk\",\"4gmsk\",\"8fsk\",\"8gfsk\",\"8msk\",\"8gmsk\",\"16fsk\",\"16gfsk\",\"16msk\",\"16gmsk\",\n", + " \"ofdm-64\",\"ofdm-72\",\"ofdm-128\",\"ofdm-180\",\"ofdm-256\",\"ofdm-300\",\"ofdm-512\",\"ofdm-600\",\n", + " \"ofdm-900\",\"ofdm-1024\",\"ofdm-1200\",\"ofdm-2048\",\n", + "] \n", + "\n", + "fft_size = 512\n", + "num_classes = len(modulation_list)\n", + "num_iq_samples = fft_size * fft_size\n", + "num_samples = 20\n", + "\n", + "data_transform = ST.Compose([\n", + " ST.Spectrogram(nperseg=fft_size, noverlap=0, nfft=fft_size, mode='complex'),\n", + " ST.Normalize(norm=np.inf, flatten=True),\n", + "])\n", + "\n", + "target_transform = ST.Compose([\n", + " ST.DescToMaskClass(num_classes=num_classes, width=fft_size, height=fft_size),\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "-----------------------------\n", + "## Instantiate the Wideband Modulations Dataset\n", + "Using the above options, the `WidebandModulationsDataset` can be instantiated as shown below. Note that when using custom data transforms, the level options should be set to either 0 or 1, where the only difference between these levels is that level 0 results in fewer signal sources per sample than level 1." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data shape: (2, 512, 512)\n", + "Label shape: (53, 512, 512)\n" + ] + } + ], + "source": [ + "wideband_modulations_dataset = WidebandModulationsDataset(\n", + " modulation_list=modulation_list,\n", + " level=2,\n", + " num_iq_samples=num_iq_samples,\n", + " num_samples=num_samples,\n", + " transform=data_transform,\n", + " target_transform=target_transform,\n", + ")\n", + "\n", + "data, label = wideband_modulations_dataset[0]\n", + "print(\"Data shape: {}\".format(data.shape))\n", + "print(\"Label shape: {}\".format(label.shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "---\n", + "### Data Plotting\n", + "After the dataset is instantiated, it can be viewed using the `MaskClassVisualizer` to verify both the transformed data and transformed annotations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_loader = DataLoader(\n", + " dataset=wideband_modulations_dataset,\n", + " batch_size=16,\n", + " shuffle=True,\n", + ")\n", + "\n", + "visualizer = MaskClassVisualizer(\n", + " data_loader=data_loader,\n", + " visualize_transform=complex_spectrogram_to_magnitude,\n", + " visualize_target_transform=mask_class_to_outline,\n", + " class_list=modulation_list,\n", + ")\n", + "\n", + "for figure in iter(visualizer):\n", + " figure.set_size_inches(16, 16)\n", + " plt.show()\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/05_example_wideband_detector.ipynb b/examples/05_example_wideband_detector.ipynb new file mode 100644 index 0000000..36c69fa --- /dev/null +++ b/examples/05_example_wideband_detector.ipynb @@ -0,0 +1,635 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3853186c", + "metadata": { + "tags": [] + }, + "source": [ + "# Example 06 - Wideband Modulations Signal Detector\n", + "This notebook walks through the process of using TorchSig to instantiate the WBSig53 dataset, load a pretrained DETR model, train the DETR model for signal detection, and evaluate its performance through plots and mean average precision (mAP) scores." + ] + }, + { + "cell_type": "markdown", + "id": "45c1adfb-b2f7-42d2-bd83-c445093a9bed", + "metadata": { + "tags": [] + }, + "source": [ + "----\n", + "### Import Libraries\n", + "First, import all the necessary public libraries as well as a few classes from the `torchsig` toolkit." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "60290c9d", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import torch\n", + "import numpy as np\n", + "import pandas as pd\n", + "from tqdm import tqdm\n", + "import matplotlib as mpl\n", + "import pytorch_lightning as pl\n", + "import matplotlib.pyplot as plt\n", + "from torch.utils.data import DataLoader\n", + "from torchmetrics.detection import MeanAveragePrecision\n", + "\n", + "import torchsig\n", + "import torchsig.transforms as ST\n", + "from torchsig.datasets import WidebandSig53" + ] + }, + { + "cell_type": "markdown", + "id": "d9ab25c8-180c-4e59-8055-d9265bd66667", + "metadata": { + "tags": [] + }, + "source": [ + "----\n", + "### Instantiate WBSig53 Dataset\n", + "Here, we instantiate the WBSig53 dataset for training and validation. Please see example notebook 03 for more details on WBSig53. If you plan to compare your results with the baseline performance metrics, please use the impaired datasets by setting `impaired = True`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c0cef0f1-2d6c-4090-aedb-8fbc9f443ecd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Existing data found, skipping data generation\n", + "Existing data found, skipping data generation\n", + "Training Dataset length: 25000\n", + "Validation Dataset length: 25000\n", + "Data shape: (2, 512, 512)\n", + "Label: {'labels': tensor([0, 0, 0]), 'boxes': tensor([[0.5000, 0.2834, 1.0000, 0.3652],\n", + " [0.5000, 0.6327, 1.0000, 0.0589],\n", + " [0.5000, 0.8892, 1.0000, 0.0948]])}\n" + ] + } + ], + "source": [ + "# Specify WidebandSig53 Options\n", + "root = 'wideband_sig53/'\n", + "train = True\n", + "impaired = False\n", + "fft_size = 512\n", + "num_classes = 1\n", + "\n", + "transform = ST.Compose([\n", + " ST.Spectrogram(nperseg=fft_size, noverlap=0, nfft=fft_size, mode='complex'),\n", + " ST.Normalize(norm=np.inf, flatten=True),\n", + "])\n", + "\n", + "target_transform = ST.Compose([\n", + " ST.DescToBBoxSignalDict(),\n", + "])\n", + "\n", + "# Instantiate the training WidebandSig53 Dataset\n", + "wideband_sig53_train = WidebandSig53(\n", + " root=root, \n", + " train=train, \n", + " impaired=impaired,\n", + " transform=transform,\n", + " target_transform=target_transform,\n", + " regenerate=False,\n", + " use_signal_data=True,\n", + " gen_batch_size=1,\n", + " use_gpu=True,\n", + ")\n", + "\n", + "# Instantiate the validation WidebandSig53 Dataset\n", + "train = False\n", + "wideband_sig53_val = WidebandSig53(\n", + " root=root, \n", + " train=train, \n", + " impaired=impaired,\n", + " transform=transform,\n", + " target_transform=target_transform,\n", + " regenerate=False,\n", + " use_signal_data=True,\n", + " gen_batch_size=1,\n", + " use_gpu=True,\n", + ")\n", + "\n", + "\n", + "# Retrieve a sample and print out information\n", + "idx = np.random.randint(len(wideband_sig53_val))\n", + "data, label = wideband_sig53_val[idx]\n", + "print(\"Training Dataset length: {}\".format(len(wideband_sig53_train)))\n", + "print(\"Validation Dataset length: {}\".format(len(wideband_sig53_val)))\n", + "print(\"Data shape: {}\".format(data.shape))\n", + "print(\"Label: {}\".format(label))" + ] + }, + { + "cell_type": "markdown", + "id": "f656424f-f14d-46de-bd28-471772c8e27a", + "metadata": { + "tags": [] + }, + "source": [ + "----\n", + "### Format Dataset for Training\n", + "Next, the datasets are then wrapped as `DataLoaders` to prepare for training." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "adf06854-b22f-4269-8661-e9cab52b39ba", + "metadata": {}, + "outputs": [], + "source": [ + "def collate_fn(batch):\n", + " return tuple(zip(*batch))\n", + "\n", + "# Create dataloaders\n", + "train_dataloader = DataLoader(\n", + " dataset=wideband_sig53_train,\n", + " batch_size=16,\n", + " num_workers=8,\n", + " shuffle=True,\n", + " drop_last=True,\n", + " collate_fn=collate_fn,\n", + ")\n", + "\n", + "val_dataloader = DataLoader(\n", + " dataset=wideband_sig53_val,\n", + " batch_size=16,\n", + " num_workers=8,\n", + " shuffle=False,\n", + " drop_last=True,\n", + " collate_fn=collate_fn,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "512ba10b-b06b-4b3d-86f7-48e04e6a98d5", + "metadata": { + "tags": [] + }, + "source": [ + "----\n", + "### Instantiate Supported TorchSig Model\n", + "Below, we load a pretrained DETR-B0-Nano model, and then conform it to a PyTorch LightningModule for training." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "55dd5975-8df8-415b-b77c-4e9b730bf9a3", + "metadata": {}, + "outputs": [], + "source": [ + "model = torchsig.models.detr_b0_nano(\n", + " pretrained=True,\n", + " path=\"detr_b0_nano.pt\",\n", + ")\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "model = model.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f62868ef-ceba-4a0c-a2ea-0197493c6411", + "metadata": {}, + "outputs": [], + "source": [ + "class ExampleDETR(pl.LightningModule):\n", + " def __init__(self, model, data_loader, val_data_loader):\n", + " super(ExampleDETR, self).__init__()\n", + " self.mdl = model\n", + " self.data_loader = data_loader\n", + " self.val_data_loader = val_data_loader\n", + " self.loss_fn = torchsig.models.spectrogram_models.detr.SetCriterion()\n", + " \n", + " # Hyperparameters\n", + " self.lr = 0.001\n", + " self.batch_size = data_loader.batch_size\n", + " \n", + " def forward(self, x):\n", + " return self.mdl(x)\n", + "\n", + " def predict(self, x):\n", + " with torch.no_grad():\n", + " out = self.forward(x)\n", + " return out\n", + " \n", + " def configure_optimizers(self):\n", + " return torch.optim.Adam(self.parameters(), lr=self.lr)\n", + " \n", + " def train_dataloader(self):\n", + " return self.data_loader\n", + " \n", + " def training_step(self, batch, _):\n", + " x, y = batch\n", + " x = torch.stack([torch.as_tensor(xi, device=\"cuda\") for xi in x], dim=0)\n", + " y_hat = self.forward(x)\n", + " loss_vals = self.loss_fn(y_hat, y)\n", + " loss = self.loss_fn.weight_dict[\"loss_ce\"] * loss_vals[\"loss_ce\"] + \\\n", + " self.loss_fn.weight_dict[\"loss_bbox\"] * loss_vals[\"loss_bbox\"] + \\\n", + " self.loss_fn.weight_dict[\"loss_giou\"] * loss_vals[\"loss_giou\"]\n", + " return {'loss':loss}\n", + " \n", + " def val_dataloader(self):\n", + " return self.val_data_loader\n", + " \n", + " def validation_step(self, batch, _):\n", + " x, y = batch\n", + " x = torch.stack([torch.as_tensor(xi, device=\"cuda\") for xi in x], dim=0)\n", + " y_hat = self.forward(x)\n", + " loss_vals = self.loss_fn(y_hat, y)\n", + " loss = self.loss_fn.weight_dict[\"loss_ce\"] * loss_vals[\"loss_ce\"] + \\\n", + " self.loss_fn.weight_dict[\"loss_bbox\"] * loss_vals[\"loss_bbox\"] + \\\n", + " self.loss_fn.weight_dict[\"loss_giou\"] * loss_vals[\"loss_giou\"]\n", + " return {'val_loss': loss}\n", + " \n", + " def validation_epoch_end(self, outputs):\n", + " val_loss_mean = sum([o['val_loss'] for o in outputs]) / len(outputs)\n", + " self.log('val_loss', val_loss_mean, prog_bar=True)\n", + " \n", + "example_model = ExampleDETR(model, train_dataloader, val_dataloader)" + ] + }, + { + "cell_type": "markdown", + "id": "9b5575fc-7629-4a24-900a-e405b512bff4", + "metadata": { + "tags": [] + }, + "source": [ + "----\n", + "### Train the Model\n", + "To train the model, we first create a `ModelCheckpoint` to monitor the validation loss over time and save the best model as we go. The network is then instantiated and passed into a `Trainer` to kick off training." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69d926e9-bc15-4f4a-a27e-c0b8e24845c9", + "metadata": {}, + "outputs": [], + "source": [ + "# Setup checkpoint callbacks\n", + "checkpoint_filename = \"{}/checkpoints/checkpoint\".format(os.getcwd())\n", + "checkpoint_callback = pl.callbacks.ModelCheckpoint(\n", + " filename=checkpoint_filename,\n", + " save_top_k=True,\n", + " verbose=True,\n", + " monitor='val_loss',\n", + " mode='min',\n", + ")\n", + "\n", + "# Create and fit trainer\n", + "epochs = 50\n", + "trainer = pl.Trainer(max_epochs=epochs, callbacks=checkpoint_callback, accelerator='gpu', devices=1)\n", + "trainer.fit(example_model)" + ] + }, + { + "cell_type": "markdown", + "id": "76f8edf8-dc0a-41bc-bf86-1ee2dc76f0ff", + "metadata": { + "tags": [] + }, + "source": [ + "----\n", + "### Evaluate the Trained Model\n", + "Once the network is fully trained, we load the best checkpoint and then infer over a few random samples, inspecting the performance through plots." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "93867565-0ade-4687-b2b2-23de73a6c27e", + "metadata": {}, + "outputs": [], + "source": [ + "# Load best checkpoint\n", + "checkpoint = torch.load(checkpoint_filename+\".ckpt\", map_location=lambda storage, loc: storage)\n", + "example_model.load_state_dict(checkpoint['state_dict'])\n", + "example_model = example_model.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3cd5c210-cffa-46b2-a67d-24f4b253db2a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "preds = {}\n", + "data_collection = {}\n", + "label_collection = {}\n", + "results_collection = {}\n", + "\n", + "threshold = 0.8\n", + "fft_size = 512\n", + "\n", + "num_eval = 6\n", + "for p in range(num_eval):\n", + " # Retrieve data\n", + " idx = np.random.randint(len(wideband_sig53_val))\n", + " data, label = wideband_sig53_val[idx]\n", + " data_collection[p] = data\n", + " \n", + " # Infer\n", + " with torch.no_grad():\n", + " data = torch.from_numpy(np.expand_dims(data,0)).float()\n", + " data = data.cuda() if torch.cuda.is_available() else data\n", + " pred = example_model(data)\n", + " preds[p] = pred\n", + " \n", + " # Convert output to detections dataframe\n", + " component_num = 0\n", + " column_names = [\"DetectionIdx\", \"Probability\", \"CenterTimePixel\", \"DurationPixel\", \"CenterFreqPixel\", \"BandwidthPixel\", \"Class\"]\n", + " detected_signals_df = pd.DataFrame(columns = column_names)\n", + " \n", + " # Loop over the number of objects DETR outputs\n", + " for obj_idx in range(pred['pred_logits'].shape[1]):\n", + " probs = pred['pred_logits'][0][obj_idx].softmax(-1)\n", + " max_prob = probs.max().cpu().detach().numpy()\n", + " max_class = probs.argmax().cpu().detach().numpy()\n", + " \n", + " # If max class is not the last class for no object, interpret values\n", + " if max_class != (pred['pred_logits'].shape[2] - 1) and max_prob > threshold:\n", + " center_time = pred['pred_boxes'][0][obj_idx][0]\n", + " center_freq = pred['pred_boxes'][0][obj_idx][1]\n", + " duration = pred['pred_boxes'][0][obj_idx][2]\n", + " bandwidth = pred['pred_boxes'][0][obj_idx][3]\n", + " \n", + " # Save to dataframe\n", + " detected_signals_df.at[component_num,\"DetectionIdx\"] = component_num\n", + " detected_signals_df.at[component_num,\"Probability\"] = max_prob\n", + " detected_signals_df.at[component_num,\"CenterTimePixel\"] = center_time.cpu().detach().numpy() * fft_size\n", + " detected_signals_df.at[component_num,\"DurationPixel\"] = duration.cpu().detach().numpy() * fft_size\n", + " detected_signals_df.at[component_num,\"CenterFreqPixel\"] = center_freq.cpu().detach().numpy() * fft_size\n", + " detected_signals_df.at[component_num,\"BandwidthPixel\"] = bandwidth.cpu().detach().numpy() * fft_size\n", + " detected_signals_df.at[component_num,\"Class\"] = max_class\n", + " component_num += 1\n", + "\n", + " # Save to results collection\n", + " results_collection[p] = detected_signals_df\n", + " \n", + " # Convert label to labels dataframe\n", + " component_num = 0\n", + " labels_df = pd.DataFrame(columns = column_names)\n", + " \n", + " for label_obj_idx in range(len(label['labels'])):\n", + " center_time = label[\"boxes\"][label_obj_idx][0]\n", + " center_freq = label[\"boxes\"][label_obj_idx][1]\n", + " duration = label[\"boxes\"][label_obj_idx][2]\n", + " bandwidth = label[\"boxes\"][label_obj_idx][3]\n", + " class_name = label[\"labels\"][label_obj_idx]\n", + "\n", + " # Save to dataframe\n", + " labels_df.at[component_num,\"DetectionIdx\"] = component_num\n", + " labels_df.at[component_num,\"Probability\"] = 1.0\n", + " labels_df.at[component_num,\"CenterTimePixel\"] = center_time * fft_size\n", + " labels_df.at[component_num,\"DurationPixel\"] = duration * fft_size\n", + " labels_df.at[component_num,\"CenterFreqPixel\"] = center_freq * fft_size\n", + " labels_df.at[component_num,\"BandwidthPixel\"] = bandwidth * fft_size\n", + " labels_df.at[component_num,\"Class\"] = class_name\n", + " component_num += 1\n", + "\n", + " # Save to label collection\n", + " label_collection[p] = labels_df" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b1311f5d-d3e3-4630-9fe1-2590617e9534", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "include_annotation = False\n", + "\n", + "plt.figure(figsize=(15, 25))\n", + "for i in range(num_eval):\n", + " ax = plt.subplot(num_eval,3,i+1)\n", + " \n", + " # Convert complex spectrogram to magnitude for plotting\n", + " data_plot = np.squeeze(data_collection[i])\n", + " data_plot = data_plot[0]**2 + data_plot[1]**2\n", + " data_plot = 20*np.log10(data_plot)\n", + "\n", + " # Retrieve individual label\n", + " ax.imshow(data_plot)\n", + " for sig_idx in range(results_collection[i].shape[0]):\n", + " rect = mpl.patches.Rectangle(\n", + " (results_collection[i].iloc[sig_idx][\"CenterTimePixel\"]-results_collection[i].iloc[sig_idx][\"DurationPixel\"]/2,\n", + " results_collection[i].iloc[sig_idx][\"CenterFreqPixel\"]-results_collection[i].iloc[sig_idx][\"BandwidthPixel\"]/2),\n", + " results_collection[i].iloc[sig_idx][\"DurationPixel\"],\n", + " results_collection[i].iloc[sig_idx][\"BandwidthPixel\"],\n", + " linewidth=1,\n", + " edgecolor='r',\n", + " facecolor='none'\n", + " )\n", + " ax.add_patch(rect)\n", + " \n", + " if include_annotation:\n", + " ax.annotate(\n", + " \"{:.1f}%\".format(results_collection[i].iloc[sig_idx][\"Probability\"]*100), \n", + " (\n", + " results_collection[i].iloc[sig_idx][\"CenterTimePixel\"]+results_collection[i].iloc[sig_idx][\"DurationPixel\"]/2, \n", + " results_collection[i].iloc[sig_idx][\"CenterFreqPixel\"]-results_collection[i].iloc[sig_idx][\"BandwidthPixel\"]/2\n", + " ), \n", + " color='w', \n", + " weight='bold', \n", + " fontsize=8, \n", + " ha='right', \n", + " va='bottom',\n", + " )\n", + " \n", + " plt.title(\"DETR Bounding Boxes\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "bd21b745-1b3d-46bb-8885-33019413c1bf", + "metadata": { + "tags": [] + }, + "source": [ + "----\n", + "### Compute the Mean Average Precision\n", + "As a final evaluation technique, we use the TorchMetrics's `MeanAveragePrecision` metric for computing the mAP. Please note that the TorchMetrics mAP computation is fairly slow, but it is the recommended tool for comparing to the performance baselines we provide." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0220061d-3d61-4102-9452-5289f941bcdc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:10<00:00, 1.50it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing metrics...\n", + "Done computing metrics in 21.20s\n", + "mAP: 0.9502255320549011\n" + ] + }, + { + "data": { + "text/plain": [ + "{'map': tensor(0.9502),\n", + " 'map_50': tensor(0.9901),\n", + " 'map_75': tensor(0.9895),\n", + " 'map_small': tensor(0.9071),\n", + " 'map_medium': tensor(0.9442),\n", + " 'map_large': tensor(0.9689),\n", + " 'mar_1': tensor(0.2776),\n", + " 'mar_10': tensor(0.9523),\n", + " 'mar_100': tensor(0.9662),\n", + " 'mar_small': tensor(0.9329),\n", + " 'mar_medium': tensor(0.9728),\n", + " 'mar_large': tensor(0.9751),\n", + " 'map_per_class': tensor(-1.),\n", + " 'mar_100_per_class': tensor(-1.)}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mAP_metric = MeanAveragePrecision(class_metrics=False)\n", + "\n", + "fft_size = 512\n", + "batch_size = 32\n", + "num_eval = len(wideband_sig53_val)\n", + "data_idx = 0\n", + "\n", + "fp16 = True\n", + "\n", + "model = model.eval().cuda()\n", + "if fp16:\n", + " # Note: only the backbone supports fp16 precision at this time\n", + " model.backbone = model.backbone.half()\n", + " model.conv = model.conv.half()\n", + " model.transformer = model.transformer.float()\n", + " model.linear_class = model.linear_class.float()\n", + " model.linear_bbox = model.linear_bbox.float()\n", + "else:\n", + " model.backbone = model.backbone.float()\n", + " model.conv = model.conv.float()\n", + " model.transformer = model.transformer.float()\n", + " model.linear_class = model.linear_class.float()\n", + " model.linear_bbox = model.linear_bbox.float()\n", + "\n", + "for curr_batch in tqdm(range(num_eval // batch_size)):\n", + " # Create batch\n", + " batch = np.zeros((batch_size, 2, fft_size, fft_size))\n", + " label_batch = []\n", + " for batch_element in range(batch_size):\n", + " # Retrieve data\n", + " idx = data_idx if num_eval == len(wideband_sig53_val) else np.random.randint(len(wideband_sig53_val))\n", + " data_idx += 1\n", + " data, label = wideband_sig53_val[idx]\n", + " batch[batch_element,:] = data\n", + " label_batch.append(label)\n", + " \n", + " # Infer\n", + " with torch.no_grad():\n", + " model_input = torch.from_numpy(batch)\n", + " model_input = model_input.cuda() if torch.cuda.is_available() else model_input\n", + " if fp16:\n", + " x = model.backbone(model_input.half())\n", + " h = model.conv(x)\n", + " h = model.transformer(h.float()).float()\n", + " preds = {\n", + " 'pred_logits': model.linear_class(h), \n", + " 'pred_boxes': model.linear_bbox(h).sigmoid()\n", + " }\n", + " else:\n", + " preds = model(model_input.float())\n", + " \n", + " # Format the predictions to match the torchmetrics input format\n", + " map_preds = torchsig.models.spectrogram_models.detr.format_preds(preds)\n", + " map_targets = torchsig.models.spectrogram_models.detr.format_targets(label_batch)\n", + " mAP_score = mAP_metric.update(map_preds, map_targets)\n", + " \n", + "# Calc mAP\n", + "print(\"Computing metrics...\")\n", + "start_time = time.time()\n", + "mAP_dict = mAP_metric.compute()\n", + "mAP_score = float(mAP_dict['map'].numpy())\n", + "print(\"Done computing metrics in {:.2f}s\".format(time.time() - start_time))\n", + "\n", + "print(\"mAP: {}\".format(mAP_score))\n", + "mAP_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91d853db-b0a2-4c01-8c78-a3f70f2cf4d4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements.txt b/requirements.txt index 6c07b17..c6d4bb0 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,5 @@ torch +torchvision>=0.10.0 tqdm numpy scipy @@ -13,4 +14,5 @@ scikit-learn gdown icecream timm==0.5.4 +segmentation_models_pytorch pytorch_lightning \ No newline at end of file diff --git a/setup.py b/setup.py index f5b03e5..faa319b 100644 --- a/setup.py +++ b/setup.py @@ -1,12 +1,19 @@ -#!/usr/bin/env python +import os import setuptools from distutils.core import setup +with open("README.md") as f: + long_description = f.read() + +exec(open('torchsig/version.py').read()) + setup( - name='torchsig', - version='0.1.0', - description='Signal Processing Machine Learning Toolkit', - author='TorchSig Team', - url='https://github.com/torchdsp/torchsig', - packages=setuptools.find_packages(), + name='torchsig', + version=__version__, + description='Signal Processing Machine Learning Toolkit', + long_description=long_description, + long_description_content_type="text/markdown", + author='TorchSig Team', + url='https://github.com/torchdsp/torchsig', + packages=setuptools.find_packages(), ) diff --git a/torchsig/__init__.py b/torchsig/__init__.py index c4205fe..ea58c63 100644 --- a/torchsig/__init__.py +++ b/torchsig/__init__.py @@ -2,3 +2,4 @@ from torchsig import datasets from torchsig import utils from torchsig import models +from .version import __version__ \ No newline at end of file diff --git a/torchsig/datasets/__init__.py b/torchsig/datasets/__init__.py index 90aee75..25228b1 100644 --- a/torchsig/datasets/__init__.py +++ b/torchsig/datasets/__init__.py @@ -1,4 +1,7 @@ from .synthetic import * from .modulations import * from .sig53 import Sig53 -from .radioml import * \ No newline at end of file +from .radioml import * +from .wideband import * +from .wideband_sig53 import WidebandSig53 +from .file_datasets import * \ No newline at end of file diff --git a/torchsig/datasets/conf.py b/torchsig/datasets/conf.py index a6437a1..47e1f76 100644 --- a/torchsig/datasets/conf.py +++ b/torchsig/datasets/conf.py @@ -60,4 +60,44 @@ class Sig53ImpairedEbNoValConfig(Sig53ImpairedTrainConfig): name: str = "sig53_impaired_ebno_val" seed: int = 1234567893 eb_no: bool = True - num_samples: int = 106_000 \ No newline at end of file + num_samples: int = 106_000 + + +@dataclass +class WidebandSig53Config: + name: str + num_samples: int + level: int + seed: int + num_iq_samples: int = int(512*512) + use_gpu: bool = True + + +@dataclass +class WidebandSig53CleanTrainConfig(WidebandSig53Config): + name: str = "wideband_sig53_clean_train" + seed: int = 1234567890 + num_samples: int = 250_000 + level: int = 1 + + +@dataclass +class WidebandSig53CleanValConfig(WidebandSig53CleanTrainConfig): + name: str = "wideband_sig53_clean_val" + seed: int = 1234567891 + num_samples: int = 25_000 + + +@dataclass +class WidebandSig53ImpairedTrainConfig(WidebandSig53Config): + name: str = "wideband_sig53_impaired_train" + seed: int = 1234567892 + num_samples: int = 250_000 + level: int = 2 + + +@dataclass +class WidebandSig53ImpairedValConfig(WidebandSig53ImpairedTrainConfig): + name: str = "wideband_sig53_impaired_val" + seed: int = 1234567893 + num_samples: int = 25_000 diff --git a/torchsig/datasets/file_datasets.py b/torchsig/datasets/file_datasets.py new file mode 100644 index 0000000..15d4eee --- /dev/null +++ b/torchsig/datasets/file_datasets.py @@ -0,0 +1,802 @@ +import os +import xml +import json +import numpy as np +import pandas as pd +import xml.etree.ElementTree as ET +from typing import List, Optional, Any + +from torchsig.utils.types import SignalDescription +from torchsig.datasets.wideband import BurstSourceDataset, SignalBurst +from torchsig.transforms.functional import to_distribution, uniform_continuous_distribution, uniform_discrete_distribution +from torchsig.transforms.functional import FloatParameter, NumericParameter + + +class TargetInterpreter: + """The TargetInterpreter base class is meant to be inherited and modified + for specific interpreters such that each sub-class implements a transform + from a file containing target information into a BurstCollection containing + SignalBursts. + + Args: + target_file: (:obj:`str`): + The file containing label/target/annotation information + + num_iq_samples: (:obj:`int`): + The number of IQ samples for each example in the dataset being + generated + + capture_duration_samples: (:obj:`int`): + The total number of IQ samples in the original capture file + + class_list: (:obj:`list`): + List of class names for class to binary encoding + + """ + def __init__( + self, + target_file: str = None, + num_iq_samples: int = int(512*512), + capture_duration_samples: int = int(512*512), + class_list: list = [], + ): + self.target_file = target_file + self.num_iq_samples = num_iq_samples + self.capture_duration_samples = capture_duration_samples + self.class_list = class_list + # Initialize relevant capture parameters to be overwritten by interpreter + self.sample_rate = 1 + self.is_complex = True + # Initialize the detections dataframe using sub-class's interpreters + self.detections_df = self._convert_to_dataframe() + self.detections_df.sort_values(by=['start']) + self.num_labels = len(self.detections_df) + self.detections_df = self._convert_class_name_to_index() + + def _convert_to_dataframe(self) -> pd.DataFrame: + """Meant to be implemented by a sub-class specific to the label file, + converting labels into a dataframe with the following columns for a + uniform setup prior to generalized burst conversions. + + """ + detection_columns = ["start", "stop", "center_freq", "bandwidth", "class_name"] + self.detections_df = pd.DataFrame(columns = detection_columns) + return self.detections_df + + def _convert_class_name_to_index(self) -> pd.DataFrame: + """Append a column to the dataframe containing the class index + associated with the class names + + """ + # If no input class_list ordering provided, read from dataframe + if self.class_list == []: + self.class_list = list(self.detections_df['class_name'].unique()) + # Append class index column + self.detections_df['class_index'] = [self.class_list.index(self.detections_df['class_name'][i]) for i in range(self.num_labels)] + return self.detections_df + + def convert_to_signalburst( + self, + start_sample: int = 0, + df_indicies: np.array = None, + ) -> List[SignalBurst]: + """Inputs a start sample and an array of indicies to convert into a + list of `SignalBursts` for the `WidebandFileSignalBurst`s + + """ + signal_bursts = [] + if df_indicies is None: + # Defaults to full dataframe + df_indicies = np.arange(self.num_labels) + + for label in self.detections_df.iloc[df_indicies].itertuples(): + # Determine cut vs full capture relationship + startInWindow = bool(label.start >= start_sample and label.start < start_sample + self.num_iq_samples) + stopInWindow = bool(label.stop > start_sample and label.stop <= start_sample + self.num_iq_samples) + spansFullWindow = bool(label.start <= start_sample and label.stop >= start_sample + self.num_iq_samples) + fullyContainedInWindow = bool(startInWindow and stopInWindow) + + # Normalize freq information + center_freq = label.center_freq / self.sample_rate + center_freq = center_freq if self.is_complex else center_freq / 2 + bandwidth = label.bandwidth / self.sample_rate + bandwidth = bandwidth if self.is_complex else bandwidth / 2 + + # If label present, normalize with respect to requested window and append + if fullyContainedInWindow: + start = (label.start - start_sample) / self.num_iq_samples + stop = (label.stop - start_sample) / self.num_iq_samples + signal_bursts.append( + WidebandFileSignalBurst( + num_iq_samples = self.num_iq_samples, + start = start, + stop = stop, + center_frequency = center_freq, + bandwidth = bandwidth, + class_name = label.class_name, + class_index = label.class_index, + random_generator = np.random.RandomState, + ) + ) + + elif startInWindow: + start = (label.start - start_sample) / self.num_iq_samples + stop = 1 + signal_bursts.append( + WidebandFileSignalBurst( + num_iq_samples = self.num_iq_samples, + start = start, + stop = stop, + center_frequency = center_freq, + bandwidth = bandwidth, + class_name = label.class_name, + class_index = label.class_index, + random_generator = np.random.RandomState, + ) + ) + + elif stopInWindow: + start = 0 + stop = (label.stop - start_sample) / self.num_iq_samples + signal_bursts.append( + WidebandFileSignalBurst( + num_iq_samples = self.num_iq_samples, + start = start, + stop = stop, + center_frequency = center_freq, + bandwidth = bandwidth, + class_name = label.class_name, + class_index = label.class_index, + random_generator = np.random.RandomState, + ) + ) + + elif spansFullWindow: + start = 0 + stop = 1 + signal_bursts.append( + WidebandFileSignalBurst( + num_iq_samples = self.num_iq_samples, + start = start, + stop = stop, + center_frequency = center_freq, + bandwidth = bandwidth, + class_name = label.class_name, + class_index = label.class_index, + random_generator = np.random.RandomState, + ) + ) + return signal_bursts + + +class CSVFileInterpreter(TargetInterpreter): + """The CSVFileInterpreter implements the transformation from a CSV- + formatted signal annotation into a List of WidebandFileSignalBursts. Expected + input is a CSV file where each row contains a separate signal annotation, + and the annotation details are separated by commas for each column. + Information about how the CSV was generated and the original capture file + are passed in such that the normalized labels for the requested dataset can + be calculated + + Example CSV format: + ``` + index,start_sample,stop_sample,center_freq,bandwidth,class_name + 0,200,14000,800000000,5000000,signal_0 + 1,1300,4000,425000000,1000000,signal_1 + ``` + Input args: + start_column=1 + stop_column=2 + center_freq_column=3 + bandwidth_column=4 + class_column=5 + + Args: + target_file: (:obj:`str`): + The file containing label/target/annotation information + + num_iq_samples: (:obj:`int`): + Number of IQ samples being requested at the TorchSig SignalDataset side + + capture_duration_samples: (:obj:`int`): + Total number of IQ samples present in the original data file + + class_list: (:obj:`list`): + List of class names for class to binary encoding + + sample_rate: (:obj:`float`): + Sample rate of data capture + + is_complex: (:obj:`bool`): + Specify whether data capture is complex or real + + start_column: (:obj:`int`): + Column index for start sample + + stop_column: (:obj:`int`): + Column index for stop sample + + center_freq_column: (:obj:`int`): + Column index for center frequency in Hz + + bandwidth_column: (:obj:`int`): + Column index for bandwidth in Hz + + class_column: (:obj:`int`): + Column index for class name + + """ + def __init__( + self, + target_file: str = None, + num_iq_samples: int = int(512*512), + capture_duration_samples: int = int(512*512), + class_list: list = [], + sample_rate: float = 25e6, + is_complex: bool = True, + start_column: int = 1, + stop_column: int = 2, + center_freq_column: int = 3, + bandwidth_column: int = 4, + class_column: int = 5, + **kwargs + ): + self.target_file = target_file + self.num_iq_samples = num_iq_samples + self.capture_duration_samples = capture_duration_samples + self.class_list = class_list + self.sample_rate = sample_rate + self.is_complex = is_complex + self.start_column = start_column + self.stop_column = stop_column + self.center_freq_column = center_freq_column + self.bandwidth_column = bandwidth_column + self.class_column = class_column + # Generate dataframe + self.detections_df = self._convert_to_dataframe() + self.detections_df = self.detections_df.sort_values(by=['start']).reset_index(drop=True) + self.num_labels = len(self.detections_df) + self.detections_df = self._convert_class_name_to_index() + + def _convert_to_dataframe(self) -> pd.DataFrame: + # Initialize dataframe + detection_columns = ["start", "stop", "center_freq", "bandwidth", "class_name"] + self.detections_df = pd.DataFrame(columns = detection_columns) + + # Read CSV into temporary dataframe + df = pd.read_csv(self.target_file) + + # Store information into detections dataframe + self.detections_df["class_name"] = df.iloc[:,self.class_column].tolist() + self.detections_df["class_indices"] = [self.class_list.index(n) for n in self.detections_df["class_name"]] + self.detections_df["start"] = df.iloc[:,self.start_column].tolist() + self.detections_df["stop"] = df.iloc[:,self.stop_column].tolist() + self.detections_df["center_freq"] = df.iloc[:,self.center_freq_column].tolist() + self.detections_df["bandwidth"] = df.iloc[:,self.bandwidth_column].tolist() + + return self.detections_df + + +class SigMFInterpreter(TargetInterpreter): + """The SigMFInterpreter reads in SigMF meta file information and maps the + annotations into SignalBursts + + Args: + target_file: (:obj:`str`): + The file containing label/target/annotation information + + num_iq_samples: (:obj:`int`): + Number of IQ samples being requested at the TorchSig SignalDataset side + + capture_duration_samples: (:obj:`int`): + Total number of IQ samples present in the original data file + + class_list: (:obj:`list`): + List of class names for class to binary encoding + + class_target: (:obj:`str`): + Annotation label for the field containing the class name + + """ + def __init__( + self, + target_file: str = None, + num_iq_samples: int = int(512*512), + capture_duration_samples: int = int(512*512), + class_list: list = [], + class_target: str = 'core:description', + **kwargs + ): + self.target_file = target_file + self.num_iq_samples = num_iq_samples + self.capture_duration_samples = capture_duration_samples + self.class_list = class_list + self.class_target = class_target + # Generate dataframe + self.detections_df = self._convert_to_dataframe() + self.detections_df = self.detections_df.sort_values(by=['start']).reset_index(drop=True) + self.num_labels = len(self.detections_df) + self.detections_df = self._convert_class_name_to_index() + + def _convert_to_dataframe(self) -> pd.DataFrame: + # Initialize dataframe + detection_columns = ["start", "stop", "center_freq", "bandwidth", "class_name", "class_index"] + self.detections_df = pd.DataFrame(columns = detection_columns) + + # Read SigMF meta file + meta = json.load(open(self.target_file, "r")) + + # Read global SigMF data + self.sample_rate = int(meta["global"]["core:sample_rate"]) + data_type = meta["global"]["core:datatype"] + self.is_complex = True if "c" in data_type else False + capture_center_freq = float(meta["captures"][0]["core:frequency"]) + + # Loop through annotations + class_names = [] + class_indices = [] + starts = [] + stops = [] + center_freqs = [] + bandwidths = [] + for annotation_idx, annotation in enumerate(meta['annotations']): + # Read annotation details + class_names.append(annotation[self.class_target]) + class_indices.append(self.class_list.index(annotation[self.class_target])) + lower_freq = annotation['core:freq_lower_edge'] + upper_freq = annotation['core:freq_upper_edge'] + bandwidth = upper_freq - lower_freq + bandwidths.append(bandwidth) + center_freqs.append(lower_freq - capture_center_freq + bandwidth/2) + start = annotation['core:sample_start'] + starts.append(start) + stops.append(start + annotation['core:sample_count']) + + # Store information into detections dataframe + self.detections_df["class_name"] = class_names + self.detections_df["class_index"] = class_indices + self.detections_df["start"] = starts + self.detections_df["stop"] = stops + self.detections_df["center_freq"] = center_freqs + self.detections_df["bandwidth"] = bandwidths + + return self.detections_df + + +class WidebandFileSignalBurst(SignalBurst): + """A sub-class of SignalBurst that takes a wideband file input along with + signal annotation parameters and reads the specified data from the file + + Args: + data_file (:obj:`str`): + The file containing the IQ data to read from + + start_sample (:obj:`int`): + The IQ sample to start reading from within the IQ data file + + is_complex (:obj:`bool`): + Boolean specifying if the data file contains complex data (True) + or real data (False) + + capture_type (:obj:`numpy.dtype`): + The precision of the data capture. Defaults to int16 + + **kwargs + """ + + def __init__( + self, + data_file: str = None, + start_sample: int = 0, + is_complex: bool = True, + capture_type: np.dtype = np.dtype(np.int16), + **kwargs + ): + super(WidebandFileSignalBurst, self).__init__(**kwargs) + self.lower_frequency = self.center_frequency - self.bandwidth / 2 + self.upper_frequency = self.center_frequency + self.bandwidth / 2 + self.data_file = data_file + self.start_sample = start_sample + self.is_complex = is_complex + self.capture_type = capture_type + capture_type_is_complex = 'complex' in str(self.capture_type) + if self.is_complex and not capture_type_is_complex: + self.bytes_per_sample = int(self.capture_type.itemsize * 2) + else: + self.bytes_per_sample = self.capture_type.itemsize + + def generate_iq(self): + if self.data_file is not None: + with open(self.data_file, "rb") as file_object: + # Apply desired offset + file_object.seek(int(self.start_sample)*self.bytes_per_sample) + # Read desired number of samples from file + iq_data = np.frombuffer( + file_object.read(int(self.num_iq_samples)*self.bytes_per_sample), + dtype=self.capture_type + ).astype(np.float64).view(np.complex128) + else: + # Since only the first burst is given data information, the + # remaining bursts are set to all 0's to avoid reading the data + # file repetitively and summing with itself + iq_data = np.zeros(self.num_iq_samples, dtype=np.complex128) + return iq_data[:self.num_iq_samples] + + +class FileBurstSourceDataset(BurstSourceDataset): + """The FileBurstSourceDataset complements the SyntheticBurstSourceDataset + but rather than generating synthetic bursts and adding them together, the + FileBurstSourceDataset inputs information from files and returns labeled + SignalBursts for the capture files. The conversions from the label files to the + SignalBursts is done through an input TargetInterpreter such that the + FileBurstSourceDataset can be used with any data type coming from files + provided the interpretation class is built. + + Args: + data_files: (:obj:`List`): + List of data files to read the IQ data from + + target_files: (:obj:`List`): + List of target files to read the signal annotations from. Note that + these files should be ordered to match the data_files accordingly + + capture_type: (:obj:`np.dtype`): + Specify the data type of the capture data_files (ex: np.int16) + + is_complex: (:obj:`bool`): + Specify whether the data files are complex or real + + sample_policy: (:obj:`str`): + Specify the policy defining how samples are retrieved from the data + and annotation files. Options include: `random`, `sequential_label`, + and `sequential_iq`. Details for each below: + - `random_labels`: Randomly sample files and then labels and then read + IQ samples around the randomly sampled label + - `sequential_labels`: Sequentially iterate over the files and + labels, retrieving IQ samples around each sequential label + - `random_iq`: Randomly sample files and starting IQ samples, + regardless of labels + - `sequential_iq`: Sequentially iterate over the files, + directly iterating over IQ samples regardless of labels + + null_ratio: (:obj:`float`): + Selects the ratio of examples without labeled bursts present. Only + valid for the `random_labels` and `sequential_labels` sample + policies. For example, a ratio of 0.2 would have 0.2*num_samples + examples without bursts (noise-only) and 0.8*samples containing + labeled bursts + + target_interpreter: (:obj:`TargetInterpreter`): + TargetInterpreter class that maps teh target_files' annotations + into a BurstCollection of FileSignalBursts + + class_list: (:obj:`list`): + List of class names for class to binary encoding + + num_iq_samples: (:obj:`int`): + Number of IQ samples for each example in the dataset + + num_samples: (:obj:`int`): + Number of samples/examples to read for creating the dataset + + seed: (:obj:`Optional`): + Initialize the random seed + + """ + + def __init__( + self, + data_files: List = None, + target_files: List = None, + capture_type: np.dtype = np.dtype(np.int16), + is_complex: bool = True, + sample_policy: str = "random_labels", + null_ratio: float = 0.0, + target_interpreter: TargetInterpreter = SigMFInterpreter, + class_list: list = [], + num_iq_samples: int = int(512*512), + num_samples: int = 100, + seed: Optional[int] = None, + **kwargs + ): + super(FileBurstSourceDataset, self).__init__( + num_iq_samples=num_iq_samples, + num_samples=num_samples, + ) + self.data_files = data_files + self.target_files = target_files + self.capture_type = capture_type + self.is_complex = is_complex + self.sample_policy = sample_policy + self.null_ratio = null_ratio + self.target_interpreter = target_interpreter + self.class_list = class_list + self.num_iq_samples = num_iq_samples + self.num_samples = num_samples + self.seed = seed + + capture_type_is_complex = 'complex' in str(self.capture_type) + if self.is_complex and not capture_type_is_complex: + self.bytes_per_sample = int(self.capture_type.itemsize * 2) + else: + self.bytes_per_sample = self.capture_type.itemsize + + if "labels" in self.sample_policy: + # Set number of samples containing no bursts + self.num_null_samples = int(self.num_samples * self.null_ratio) + self.num_valid_samples = self.num_samples - self.num_null_samples + + # Distribute randomness evenly over labels, rather than files then labels + # If more than 10,000 files, omit this step for speed + if self.sample_policy == "random_labels" and len(self.target_files) < 10_000: + annotations_per_file = [] + for file_index, target_file in enumerate(self.target_files): + # Read total file size + capture_duration_samples = os.path.getsize( + os.path.join(self.data_files[file_index]) + ) // self.bytes_per_sample + # Interpret annotations for file + interpreter = self.target_interpreter( + target_file = target_file, + num_iq_samples = self.num_iq_samples, + capture_duration_samples = capture_duration_samples, + class_list = self.class_list, + ) + # Read all annotations + annotations = interpreter.detections_df + # Track number of annotations + annotations_per_file.append(len(annotations)) + total_annotations = sum(annotations_per_file) + self.file_probabilities = np.asarray(annotations_per_file) / total_annotations + + # Generate the index by creating a set of bursts. + self.index = [(collection, idx) for idx, collection in enumerate(self._generate_burst_collections())] + + def _generate_burst_collections(self) -> List[List[SignalBurst]]: + dataset = [] + + if "iq" in self.sample_policy: + file_index = 0 + data_index = 0 + for sample_idx in range(self.num_samples): + if self.sample_policy == "random_iq": + # Sample random file + file_index = np.random.randint(len(self.data_files)) + # Read total file size + capture_duration_samples = os.path.getsize( + os.path.join(self.data_files[file_index]) + ) // self.bytes_per_sample + + # Instantiate target interpreter + interpreter = self.target_interpreter( + target_file=self.target_files[file_index], + num_iq_samples = self.num_iq_samples, + capture_duration_samples = capture_duration_samples, + class_list = self.class_list, + ) + # Read all annotations + annotations = interpreter.detections_df + + # Determine data start index + if self.sample_policy == "random_iq": + if (capture_duration_samples - self.num_iq_samples) > 0: + data_index = np.random.randint(0, capture_duration_samples - self.num_iq_samples) + + # Convert labels to SignalBursts + sample_burst_collection = interpreter.convert_to_signalburst( + start_sample=data_index, + df_indicies=None, + ) + + if len(sample_burst_collection) > 0: + # Add data file information to the first SignalBurst only + sample_burst_collection[0].data_file = self.data_files[file_index] + sample_burst_collection[0].start_sample = data_index + sample_burst_collection[0].is_complex = self.is_complex + sample_burst_collection[0].capture_type = self.capture_type + capture_type_is_complex = 'complex' in str(self.capture_type) + if self.is_complex and not capture_type_is_complex: + sample_burst_collection[0].bytes_per_sample = int(self.capture_type.itemsize * 2) + else: + sample_burst_collection[0].bytes_per_sample = self.capture_type.itemsize + else: + # Create invalid SignalBurst for data file information only + sample_burst_collection = [] + sample_burst_collection.append( + WidebandFileSignalBurst( + num_iq_samples=self.num_iq_samples, + start=0, + stop=0, + center_frequency=0, + bandwidth=0, + class_name=None, + class_index=None, + data_file=self.data_files[file_index], + start_sample=data_index, + is_complex=self.is_complex, + capture_type=self.capture_type, + random_generator=np.random.RandomState, + ) + ) + + # If sequentially sampling, increment + if self.sample_policy == "sequential_iq": + data_index += self.num_iq_samples + # Check for end of lables and end of files + if (data_index + self.num_iq_samples) > capture_duration_samples: + data_index = 0 + file_index += 1 + if file_index >= len(self.data_files): + file_index = 0 + + # Save SignalBursts to dataset + dataset.append(sample_burst_collection) + + else: + # First, handle null samples + null_fail_counter = 0 + for sample_idx in range(self.num_null_samples): + # Sample random file + file_index = np.random.randint(len(self.data_files)) + # Read total file size + capture_duration_samples = os.path.getsize( + os.path.join(self.data_files[file_index]) + ) // self.bytes_per_sample + + # Instantiate target interpreter + interpreter = self.target_interpreter( + target_file=self.target_files[file_index], + num_iq_samples=self.num_iq_samples, + capture_duration_samples=capture_duration_samples, + class_list = self.class_list, + ) + # Read all annotations + annotations = interpreter.detections_df + + # Decide data_index based on annotation locations + null_interval = 0 + null_start_index = 0 + null_attempts = 0 + null_fail = False + while null_interval < self.num_iq_samples: + # Randomly sample label index to search around + label_index = np.random.randint(interpreter.num_labels) + if interpreter.num_labels > 1 and label_index+1 <= interpreter.num_labels-1: + # Max over previous annotation stop and previous null start to handle cases of long signals + null_start_index = max(annotations.iloc[label_index].stop, null_start_index) + null_stop_index = annotations.iloc[label_index+1].start + elif interpreter.num_labels > 1 and label_index + 1 > interpreter.num_labels-1: + # Start start index at end of final label + null_start_index = max(annotations.iloc[label_index].stop, null_start_index) + null_stop_index = capture_duration_samples + elif interpreter.num_labels == 1: + # Sample from before or after the only label + before = True if np.random.rand() >= 0.5 else False + null_start_index = 0 if before else annotations.iloc[0].stop + null_stop_index = annotations.iloc[0].start if before else capture_duration_samples + else: + # Sample from anywhere in file + null_start_index = 0 + null_stop_index = capture_duration_samples + null_interval = null_stop_index - null_start_index + null_attempts += 1 + if null_attempts > 100: + null_fail = True + break + if null_fail: + sample_idx -= 1 + null_fail_counter += 1 + if null_fail_counter > 100: + # Not enough null examples across files + self.num_valid_samples = self.num_samples - sample_idx + break + continue + + # Random value within null start and stop indicies - IQ samples + data_index = np.random.randint( + null_start_index, + null_stop_index-self.num_iq_samples + ) + + # Create invalid SignalBurst for data file information only + null_sample_burst_collection = [] + null_sample_burst_collection.append( + WidebandFileSignalBurst( + num_iq_samples=self.num_iq_samples, + start=0, + stop=0, + center_frequency=0, + bandwidth=0, + class_name=None, + class_index=None, + data_file=self.data_files[file_index], + start_sample=data_index, + is_complex=self.is_complex, + capture_type=self.capture_type, + random_generator=np.random.RandomState, + ) + ) + + # Append to dataset + dataset.append(null_sample_burst_collection) + + # Next, handle the valid bursts + file_index = 0 + label_index = 0 + for sample_idx in range(self.num_valid_samples): + if self.sample_policy == "random_labels": + # Sample random file, weighted by number of annotations + file_index = np.random.choice(len(self.data_files), p=self.file_probabilities) + # Read total file size + capture_duration_samples = os.path.getsize( + os.path.join(self.data_files[file_index]) + ) // self.bytes_per_sample + + # Instantiate target interpreter + interpreter = self.target_interpreter( + target_file=self.target_files[file_index], + num_iq_samples = self.num_iq_samples, + capture_duration_samples = capture_duration_samples, + class_list = self.class_list, + ) + # Read all annotations + annotations = interpreter.detections_df + + if self.sample_policy == "random_labels": + # Randomly sample specific burst label + label_index = np.random.randint(interpreter.num_labels) + burst_start_index = annotations.iloc[label_index].start + + # Step back a random number of IQ samples from the burst start index + burst_duration = annotations.iloc[label_index].stop - burst_start_index + if burst_duration < self.num_iq_samples: + if (burst_duration / self.num_iq_samples) <= 0.2: + # Very short burst: Ensure full burst is present in window + earliest_sample_index = burst_start_index - (self.num_iq_samples - burst_duration) + latest_sample_index = burst_start_index + else: + # Short burst: Ensure at least half of the burst is present in window + earliest_sample_index = burst_start_index - (self.num_iq_samples - burst_duration / 2) + latest_sample_index = burst_start_index + burst_duration / 2 + else: + # Long burst: Ensure at least a quarter of the window is occupied + earliest_sample_index = burst_start_index - (0.75 * self.num_iq_samples) + latest_sample_index = annotations.iloc[label_index].stop - (0.25 * self.num_iq_samples) + data_index = max(0,np.random.randint(earliest_sample_index, latest_sample_index)) + + # Check duration + if capture_duration_samples - data_index < self.num_iq_samples: + sample_idx -= 1 + continue + + # Convert labels to SignalBursts + sample_burst_collection = interpreter.convert_to_signalburst( + start_sample=data_index, + df_indicies=None, + ) + + # Add data file information to the first SignalBurst only + sample_burst_collection[0].data_file = self.data_files[file_index] + sample_burst_collection[0].start_sample = data_index + sample_burst_collection[0].is_complex = self.is_complex + sample_burst_collection[0].capture_type = self.capture_type + capture_type_is_complex = 'complex' in str(self.capture_type) + if self.is_complex and not capture_type_is_complex: + sample_burst_collection[0].bytes_per_sample = int(self.capture_type.itemsize * 2) + else: + sample_burst_collection[0].bytes_per_sample = self.capture_type.itemsize + + # If sequentially sampling, increment + if self.sample_policy == "sequential_labels": + label_index += len(sample_burst_collection) + # Check for end of lables and end of files + if label_index >= interpreter.num_labels: + label_index = 0 + file_index += 1 + if file_index >= len(self.data_files): + file_index = 0 + + # Save SignalBursts to dataset + dataset.append(sample_burst_collection) + + return dataset diff --git a/torchsig/datasets/synthetic.py b/torchsig/datasets/synthetic.py index c8166af..7e62969 100644 --- a/torchsig/datasets/synthetic.py +++ b/torchsig/datasets/synthetic.py @@ -1,10 +1,24 @@ +import torch +import pickle import itertools import numpy as np +from copy import deepcopy from scipy import signal as sp from collections import OrderedDict from torch.utils.data import ConcatDataset from typing import Tuple, Any, List, Union, Optional +try: + import cusignal + import cupy as xp + CUSIGNAL = True + CUPY = True +except ImportError: + import numpy as cp + CUSIGNAL = False + CUPY = False + pass + from torchsig.utils.dataset import SignalDataset from torchsig.utils.types import SignalData, SignalDescription from torchsig.transforms.functional import IntParameter, FloatParameter @@ -16,7 +30,7 @@ def remove_corners(const): return [p for p in const if np.abs(np.real(p)) < 1.0 - cutoff or np.abs(np.imag(p)) < 1.0 - cutoff] -const_map = OrderedDict({ +default_const_map = OrderedDict({ "ook": np.add(*map(np.ravel, np.meshgrid(np.linspace(0, 1, 2), 0j))), "bpsk": np.add(*map(np.ravel, np.meshgrid(np.linspace(-1, 1, 2), 0j))), "4pam": np.add(*map(np.ravel, np.meshgrid(np.linspace(0, 1, 4), 0j))), @@ -81,11 +95,17 @@ class DigitalModulationDataset(ConcatDataset): num_samples_per_class (:obj:`int`): number of samples to be kept for each class - random_data (:obj:`bool`):self.num_samples_per_class/num_subcarriers/len(cycle_prefix_ratios) + iq_samples_per_symbol (:obj:`Optional[int]`): + number of IQ samples per symbol + + random_data (:obj:`bool`): whether the modulated binary utils should be random each time, or seeded by index - transform (:obj:`Callable`, optional): - A function/transform that takes in an IQ vector and returns a transformed version. + random_pulse_shaping (:obj:`bool`): + boolean to enable/disable randomized pulse shaping + + user_const_map (:obj:`Optional[OrderedDict]`): + optional user-defined constellation map, defaults to Sig53 modulations """ def __init__( @@ -96,8 +116,10 @@ def __init__( iq_samples_per_symbol: Optional[int] = None, random_data: bool = False, random_pulse_shaping: bool = False, + user_const_map: Optional[OrderedDict] = None, **kwargs ): + const_map = user_const_map if user_const_map else default_const_map modulations = list(const_map.keys()) + list(freq_map.keys()) if modulations is None else modulations constellations = [m for m in map(str.lower, modulations) if m in const_map.keys()] freqs = [m for m in map(str.lower, modulations) if m in freq_map.keys()] @@ -193,6 +215,9 @@ class ConstellationDataset(SyntheticDataset): random_data (:obj:`bool`): whether the modulated binary utils should be random each time, or seeded by index + user_const_map (:obj:`bool`): + user constellation dict + """ def __init__( self, @@ -203,14 +228,18 @@ def __init__( pulse_shape_filter: bool = None, random_pulse_shaping: bool = False, random_data: bool = False, + use_gpu: bool = False, + user_const_map: bool = None, **kwargs ): super(ConstellationDataset, self).__init__(**kwargs) - self.constellations = list(const_map.keys()) if constellations is None else constellations + self.const_map = default_const_map if user_const_map is None else user_const_map + self.constellations = list(self.const_map.keys()) if constellations is None else constellations self.num_iq_samples = num_iq_samples self.iq_samples_per_symbol = iq_samples_per_symbol self.num_samples_per_class = num_samples_per_class self.random_pulse_shaping = random_pulse_shaping + self.use_gpu = use_gpu and torch.cuda.is_available() and CUPY and CUSIGNAL num_constellations = len(self.constellations) total_num_samples = int(num_constellations*self.num_samples_per_class) @@ -230,7 +259,7 @@ def __init__( for idx in range(self.num_samples_per_class): signal_description = SignalDescription( sample_rate=0, - bits_per_symbol=np.log2(len(const_map[const_name])), + bits_per_symbol=np.log2(len(self.const_map[const_name])), samples_per_symbol=iq_samples_per_symbol, class_name=const_name, excess_bandwidth=alphas[int(const_idx*self.num_samples_per_class+idx)], @@ -245,13 +274,14 @@ def _generate_samples(self, item: Tuple) -> np.ndarray: if not self.random_data: np.random.seed(index) - const = const_map[class_name] / np.mean(np.abs(const_map[class_name])) + const = self.const_map[class_name] / np.mean(np.abs(self.const_map[class_name])) symbol_nums = np.random.randint(0, len(const), 2 * int(self.num_iq_samples / self.iq_samples_per_symbol)) symbols = const[symbol_nums] zero_padded = np.zeros((self.iq_samples_per_symbol * len(symbols),), dtype=np.complex64) zero_padded[::self.iq_samples_per_symbol] = symbols self.pulse_shape_filter = self._rrc_taps(11, signal_description.excess_bandwidth) - filtered = np.convolve(zero_padded, self.pulse_shape_filter, "same") + xp = cp if self.use_gpu else np + filtered = xp.convolve(xp.array(zero_padded), xp.array(self.pulse_shape_filter), "same") if not self.random_data: np.random.set_state(orig_state) # return numpy back to its previous state @@ -303,19 +333,30 @@ class OFDMDataset(SyntheticDataset): sidelobe_suppression_methods (:obj:`tuple`): Tuple of possible sidelobe suppression methods. The options are: - * `none` ~ Perform no sidelobe suppression methods - * `lpf` ~ Apply a static low pass filter to the OFDM signal - * `rand_lpf` ~ Apply a low pass filter with a randomized cutoff frequency to the OFDM signal - * `win_start` ~ Apply a windowing method starting at the symbol boundary - * `win_center` ~ Apply a windowing method centered at the symbol boundary - + - `none` ~ Perform no sidelobe suppression methods + - `lpf` ~ Apply a static low pass filter to the OFDM signal + - `rand_lpf` ~ Apply a low pass filter with a randomized cutoff frequency to the OFDM signal + - `win_start` ~ Apply a windowing method starting at the symbol boundary + - `win_center` ~ Apply a windowing method centered at the symbol boundary For more details on the windowing method options, please see: http://zone.ni.com/reference/en-XX/help/373725J-01/wlangen/windowing/ dc_subcarrier (:obj:`tuple`): Tuple of possible DC subcarrier options: - * `on` ~ Always leave the DC subcarrier on - * `off` ~ Always turn the DC subcarrier off + - `(on,)` ~ Always leave the DC subcarrier on + - `(off,)` ~ Always turn the DC subcarrier off + - `(on, off)` ~ Half with DC subcarrier on and half off + + time_varying_realism (:obj:`tuple`): + Tuple of on/off/both options for adding time-varying realistic effects in the form of + bursts, pilot carriers, and resource blocks. Options: + - `(on,)` ~ Leave the time-varying effects on, with half under full bursty effects and half under partial + - `(off,)` ~ Always leave the time-varying effects off + - `(on, off)` ~ One third with full bursty effects, one third with partial, and one third off + - `(full_bursty,)` ~ All signals are bursty with consistent pattern throughout + - `(partial_bursty,)` ~ All signals are mixed with bursty and continuous regions + Note: The partial bursty behavior occurs prior to time slicing, and as such, is more interesting in longer + duration examples transform (:obj:`Callable`, optional): A function/transform that takes in an IQ vector and returns a transformed version. @@ -331,6 +372,8 @@ def __init__( random_data: bool = False, sidelobe_suppression_methods: tuple = ('none', 'lpf', 'rand_lpf', 'win_start', 'win_center'), dc_subcarrier: tuple = ('on', 'off'), + time_varying_realism: tuple = ('off',), + use_gpu: bool = False, **kwargs ): super(OFDMDataset, self).__init__(**kwargs) @@ -338,6 +381,7 @@ def __init__( self.num_iq_samples = num_iq_samples self.num_samples_per_class = num_samples_per_class self.random_data = random_data + self.use_gpu = use_gpu and torch.cuda.is_available() and CUPY and CUSIGNAL self.index = [] if 'lpf' in sidelobe_suppression_methods: # Precompute LPF @@ -354,16 +398,30 @@ def __init__( # Precompute all possible random symbols for speed at sample generation self.random_symbols = [] for const_name in self.constellations: - const = const_map[const_name] / np.mean(np.abs(const_map[const_name])) + const = default_const_map[const_name] / np.mean(np.abs(default_const_map[const_name])) self.random_symbols.append(const) subcarrier_modulation_types = ("fixed", "random") - combinations = list(itertools.product(constellations, subcarrier_modulation_types, cyclic_prefix_ratios, sidelobe_suppression_methods, dc_subcarrier)) + if 'on' in time_varying_realism: + if 'off' in time_varying_realism: + time_varying_realism = ('off', 'full_bursty', 'partial_bursty') + else: + time_varying_realism = ('full_bursty', 'partial_bursty') + combinations = list(itertools.product( + constellations, + subcarrier_modulation_types, + cyclic_prefix_ratios, + sidelobe_suppression_methods, + dc_subcarrier, + time_varying_realism + )) for class_idx, num_subcarrier in enumerate(num_subcarriers): class_name = "ofdm-{}".format(num_subcarrier) for idx in range(self.num_samples_per_class): - const_name, mod_type, cyclic_prefix_ratio, sidelobe_suppression_method, dc_subcarrier = combinations[np.random.randint(len(combinations))] + const_name, mod_type, cyclic_prefix_ratio, sidelobe_suppression_method, dc_subcarrier, time_varying_realism = combinations[ + np.random.randint(len(combinations)) + ] signal_description = SignalDescription( sample_rate=0, bits_per_symbol=2, @@ -379,6 +437,7 @@ def __init__( mod_type, sidelobe_suppression_method, dc_subcarrier, + time_varying_realism, signal_description )) @@ -390,22 +449,43 @@ def _generate_samples(self, item: Tuple) -> np.ndarray: mod_type = item[5] sidelobe_suppression_method = item[6] dc_subcarrier = item[7] + time_varying_realism = item[8] orig_state = np.random.get_state() if not self.random_data: np.random.seed(index) + # Symbol multiplier: we want to be able to randomly index into + # generated IQ samples such that we can see symbol transitions. + # This multiplier ensures enough OFDM symbols are generated for + # this randomness. + # Check against max possible requirements + # 2x for symbol length + # 2x for number of symbols for at least 1 transition + # 4x for largest burst duration option + if self.num_iq_samples <= 4*2*2*num_subcarriers: + sym_mult = self.num_iq_samples/(2*2*num_subcarriers) + 1e-6 + sym_mult = int(np.ceil(sym_mult**-1)) if sym_mult < 1.0 else int(np.ceil(sym_mult)) + else: + sym_mult = 1 + if self.num_iq_samples > 32768: + # assume wideband task and reduce data for speed + sym_mult = 0.3 + wideband = True + else: + wideband = False + if mod_type == "random": # Randomized subcarrier modulations symbols = [] for subcarrier_idx in range(num_subcarriers): curr_const = np.random.randint(len(self.random_symbols)) - symbols.extend(np.random.choice(self.random_symbols[curr_const], size=int(2*self.num_iq_samples/num_subcarriers))) + symbols.extend(np.random.choice(self.random_symbols[curr_const], size=int(2*sym_mult*self.num_iq_samples/num_subcarriers))) symbols = np.asarray(symbols) else: # Fixed modulation across all subcarriers const_name = np.random.choice(self.constellations) - const = const_map[const_name] / np.mean(np.abs(const_map[const_name])) - symbol_nums = np.random.randint(0, len(const), 2 * self.num_iq_samples) + const = default_const_map[const_name] / np.mean(np.abs(default_const_map[const_name])) + symbol_nums = np.random.randint(0, len(const), int(2*sym_mult*self.num_iq_samples)) symbols = const[symbol_nums] divisible_index = -(len(symbols) % num_subcarriers) if divisible_index != 0: @@ -424,29 +504,82 @@ def _generate_samples(self, item: Tuple) -> np.ndarray: if dc_subcarrier == 'off': dc_center = int(zero_pad.shape[0]//2) zero_pad[dc_center,:] = np.zeros((zero_pad.shape[1])) - - ofdm_symbols = np.fft.ifft(np.fft.ifftshift(zero_pad, axes=0), axis=0) - symbol_dur = ofdm_symbols.shape[0] - cyclic_prefixed = np.pad(ofdm_symbols, ((int(cyclic_prefix_len), 0), (0, 0)), 'wrap') + # Add time-varying realism with randomized bursts, pilots, and resource blocks + burst_dur = 1 + original_on = False + if time_varying_realism == 'full_bursty' or time_varying_realism == 'partial_bursty': + # Bursty + if time_varying_realism == 'full_bursty': + burst_region_start = 0 + burst_region_stop = zero_pad.shape[1] + else: + burst_region_start = np.random.uniform(0.0,0.9) + burst_region_dur = min(1.0-burst_region_start, np.random.uniform(0.25,1.0)) + burst_region_start = int(burst_region_start*zero_pad.shape[1]//4) + burst_region_dur = int(burst_region_dur*zero_pad.shape[1]//4) + burst_region_stop = burst_region_start + burst_region_dur + #bursty = deepcopy(zero_pad) + bursty = pickle.loads(pickle.dumps(zero_pad, -1)) # no random hangs like deepcopy + + burst_dur = np.random.choice([1,2,4]) + original_on = True if np.random.rand() <= 0.5 else False + for subcarrier_idx in range(bursty.shape[0]): + on = original_on + for time_idx in range(bursty.shape[1]): + if time_idx%burst_dur == 0: + on = not on + if (not on) and (time_idx >= burst_region_start and time_idx <= burst_region_stop): + bursty[subcarrier_idx, time_idx] = 0 + 1j*0 + + # Pilots + min_num_pilots = 4 + max_num_pilots = int(num_subcarriers//8) + num_pilots = np.random.randint(min_num_pilots, max_num_pilots) + pilot_indices = np.random.choice(range(num_subcarriers), num_pilots, replace=False) + bursty[pilot_indices+num_subcarriers//2,:] = zero_pad[pilot_indices+num_subcarriers//2,:] + + # Resource blocks + min_num_blocks = 2 + max_num_blocks = 16 + num_blocks = np.random.randint(min_num_blocks, max_num_blocks) + for block_idx in range(num_blocks): + block_start = np.random.uniform(0.0,0.9) + block_dur = np.random.uniform(0.05,1.0-block_start) + block_start = int(block_start*zero_pad.shape[1]) + block_dur = int(block_dur*zero_pad.shape[1]//4) + block_stop = block_start + block_dur + + block_low_carrier = np.random.randint(0, num_subcarriers-4) + block_num_carriers = np.random.randint(1, num_subcarriers//8) + block_high_carrier = min(block_low_carrier+block_num_carriers, num_subcarriers) + + bursty[ + block_low_carrier+num_subcarriers//2:block_high_carrier+num_subcarriers//2, + block_start:block_stop + ] = zero_pad[ + block_low_carrier+num_subcarriers//2:block_high_carrier+num_subcarriers//2, + block_start:block_stop + ] + zero_pad = bursty + + xp = cp if self.use_gpu else np + ofdm_symbols = xp.fft.ifft(xp.fft.ifftshift(zero_pad, axes=0), axis=0) + symbol_dur = ofdm_symbols.shape[0] + cyclic_prefixed = xp.pad(ofdm_symbols, ((int(cyclic_prefix_len), 0), (0, 0)), 'wrap') if sidelobe_suppression_method == 'none': - # randomize the start index - start_idx = np.random.randint(0,symbol_dur) - return cyclic_prefixed.T.flatten()[start_idx:start_idx+self.num_iq_samples] - + output = cyclic_prefixed.T.flatten() + elif sidelobe_suppression_method == 'lpf': flattened = cyclic_prefixed.T.flatten() # Apply pre-computed LPF - filtered = sp.fftconvolve(flattened, self.taps, mode="same") - # randomize the start index - start_idx = np.random.randint(0,symbol_dur) - return filtered[start_idx:start_idx+self.num_iq_samples] + output = xp.convolve(xp.array(flattened), xp.array(self.taps), mode="same")[:-50] elif sidelobe_suppression_method == 'rand_lpf': flattened = cyclic_prefixed.T.flatten() # Generate randomized LPF - cutoff = np.random.uniform(0.50,0.95) + cutoff = np.random.uniform(0.95,0.95) num_taps = int(np.ceil(50*2*np.pi/cutoff/.125/22)) # fred harris rule of thumb taps = sp.firwin( num_taps, @@ -456,17 +589,14 @@ def _generate_samples(self, item: Tuple) -> np.ndarray: scale=True ) # Apply random LPF - filtered = sp.fftconvolve(flattened, taps, mode="same") - # randomize the start index - start_idx = np.random.randint(0,symbol_dur) - return filtered[start_idx:start_idx+self.num_iq_samples] - + output = xp.convolve(xp.array(flattened), xp.array(taps), mode="same")[:-num_taps] + else: # Apply appropriate windowing technique window_len = cyclic_prefix_len half_window_len = int(window_len / 2) if sidelobe_suppression_method == 'win_center': - windowed = np.pad(cyclic_prefixed, ((half_window_len, half_window_len), (0, 0)), 'constant', constant_values=0) + windowed = xp.pad(cyclic_prefixed, ((half_window_len, half_window_len), (0, 0)), 'constant', constant_values=0) windowed[-half_window_len:, :] = windowed[ int(half_window_len)+int(cyclic_prefix_len):int(half_window_len)+int(cyclic_prefix_len)+int(half_window_len), : @@ -476,32 +606,45 @@ def _generate_samples(self, item: Tuple) -> np.ndarray: : ] elif sidelobe_suppression_method == 'win_start': - windowed = np.pad(cyclic_prefixed, ((0, int(window_len)), (0, 0)), 'constant', constant_values=0) + windowed = xp.pad(cyclic_prefixed, ((0, int(window_len)), (0, 0)), 'constant', constant_values=0) windowed[-int(window_len):,:] = windowed[int(cyclic_prefix_len):int(cyclic_prefix_len)+int(window_len),:] else: - raise ValueError('Expected window method to be: none, center, or start. Received: {}'.format(self.window_method)) + raise ValueError('Expected window method to be: none, win_center, or win_start. Received: {}'.format(self.window_method)) # window the tails - front_window = np.blackman(int(window_len*2))[:int(window_len)].reshape(-1, 1) - tail_window = np.blackman(int(window_len*2))[-int(window_len):].reshape(-1, 1) + front_window = xp.blackman(int(window_len*2))[:int(window_len)].reshape(-1, 1) + tail_window = xp.blackman(int(window_len*2))[-int(window_len):].reshape(-1, 1) windowed[:int(window_len), :] = front_window * windowed[:int(window_len), :] windowed[-int(window_len):, :] = tail_window * windowed[-int(window_len):, :] - if not self.random_data: - np.random.set_state(orig_state) # return numpy back to its previous state - - combined = np.zeros((windowed.shape[0]*windowed.shape[1],), dtype=complex) + combined = xp.zeros((windowed.shape[0]*windowed.shape[1],), dtype=complex) start_idx = 0 for symbol_idx in range(windowed.shape[1]): combined[start_idx:start_idx+windowed.shape[0]] += windowed[:,symbol_idx] - start_idx += (symbol_dur+int(window_len)) + start_idx += (symbol_dur+int(window_len)) + output = combined[:int(cyclic_prefixed.shape[0]*cyclic_prefixed.shape[1])] - # randomize the start index while bypassing the initial windowing - start_idx = np.random.randint(window_len,symbol_dur+window_len) + output = xp.asnumpy(output) if self.use_gpu else output + + # Randomize the start index (while bypassing the initial windowing if present) + if sym_mult == 1 and num_subcarriers*4*burst_dur < self.num_iq_samples: + start_idx = np.random.randint(0,output.shape[0]-self.num_iq_samples) + else: + if original_on: + lower = max(0,int(symbol_dur*burst_dur)-self.num_iq_samples*0.7) + upper = min(int(symbol_dur*burst_dur), output.shape[0]-self.num_iq_samples) + start_idx = np.random.randint(lower, upper) + elif 'win' in sidelobe_suppression_method: + start_idx = np.random.randint(window_len,int(symbol_dur*burst_dur)+window_len) + else: + start_idx = np.random.randint(0,int(symbol_dur*burst_dur)) + + if not self.random_data: + np.random.set_state(orig_state) # return numpy back to its previous state + + return output[start_idx:start_idx+self.num_iq_samples] - return combined[start_idx:start_idx+self.num_iq_samples] - class FSKDataset(SyntheticDataset): """FSK Dataset @@ -533,6 +676,7 @@ def __init__( iq_samples_per_symbol: int = 2, random_data: bool = False, random_pulse_shaping: bool = False, + use_gpu: bool = False, **kwargs ): super(FSKDataset, self).__init__(**kwargs) @@ -542,6 +686,7 @@ def __init__( self.iq_samples_per_symbol = iq_samples_per_symbol self.random_data = random_data self.random_pulse_shaping = random_pulse_shaping + self.use_gpu = use_gpu and torch.cuda.is_available() and CUPY and CUSIGNAL self.index = [] for freq_idx, freq_name in enumerate(map(str.lower, self.modulations)): @@ -573,39 +718,61 @@ def _generate_samples(self, item: Tuple) -> np.ndarray: np.random.seed(index) const = freq_map[const_name] - symbol_nums = np.random.randint(0, len(const), int(self.num_iq_samples)) # Create extra symbols and truncate later + symbol_nums = np.random.randint(0, len(const), int(self.num_iq_samples)) + + xp = cp if self.use_gpu else np + symbols = const[symbol_nums] - symbols_repeat = np.repeat(symbols, self.iq_samples_per_symbol) + symbols_repeat = xp.repeat(symbols, self.iq_samples_per_symbol) + filtered = symbols_repeat if "g" in const_name: taps = self._gaussian_taps(bandwidth) signal_description.excess_bandwidth = bandwidth - filtered = np.convolve(symbols_repeat, taps, "same") + filtered = xp.convolve(xp.array(symbols_repeat), xp.array(taps), "same") mod_idx = 1.0 if "fsk" in const_name else .5 - phase = np.cumsum(filtered * 1j / self.iq_samples_per_symbol * mod_idx * np.pi) - modulated = np.exp(phase) + phase = xp.cumsum(xp.array(filtered) * 1j / self.iq_samples_per_symbol * mod_idx * np.pi) + modulated = xp.exp(phase) if "g" not in const_name and self.random_pulse_shaping: # Apply a randomized LPF simulating a noisy detector/burst extractor, then downsample to ~fs/2 bw lpf_bandwidth = bandwidth num_taps = int(np.ceil(50 * 2 * np.pi / lpf_bandwidth / .125 / 22)) - taps = sp.firwin( - num_taps, - lpf_bandwidth, - width=lpf_bandwidth * .02, - window=sp.get_window("blackman", num_taps), - scale=True - ) - modulated = sp.fftconvolve(modulated, taps, mode="same") + if self.use_gpu: + taps = cusignal.firwin( + num_taps, + lpf_bandwidth, + width=lpf_bandwidth * .02, + window=sp.get_window("blackman", num_taps), + scale=True + ) + else: + taps = sp.firwin( + num_taps, + lpf_bandwidth, + width=lpf_bandwidth * .02, + window=sp.get_window("blackman", num_taps), + scale=True + ) + modulated = xp.convolve(xp.array(modulated), xp.array(taps), mode="same") new_rate = lpf_bandwidth * 2 - modulated = sp.resample_poly( - modulated, - up=np.floor(new_rate*100).astype(np.int32), - down=100, - ) + if self.use_gpu: + modulated = cusignal.resample_poly( + modulated, + up=np.floor(new_rate*100).astype(np.int32), + down=100, + ) + else: + modulated = sp.resample_poly( + modulated, + up=np.floor(new_rate*100).astype(np.int32), + down=100, + ) signal_description.samples_per_symbol = 2 # Effective samples per symbol at half bandwidth signal_description.excess_bandwidth = 0 # Reset excess bandwidth due to LPF + + modulated = xp.asnumpy(modulated) if self.use_gpu else modulated if not self.random_data: np.random.set_state(orig_state) # return numpy back to its previous state @@ -613,12 +780,13 @@ def _generate_samples(self, item: Tuple) -> np.ndarray: return modulated[-self.num_iq_samples:] def _gaussian_taps(self, BT: float = 0.35) -> np.ndarray: + xp = cp if self.use_gpu else np # pre-modulation Bb*T product which sets the bandwidth of the Gaussian lowpass filter M = 4 # duration in symbols Ns = self.iq_samples_per_symbol - n = np.arange(-M * Ns, M * Ns + 1) - p = np.exp(-2 * np.pi ** 2 * BT ** 2 / np.log(2) * (n / float(Ns)) ** 2) - p = p / np.sum(p) + n = xp.arange(-M * Ns, M * Ns + 1) + p = xp.exp(-2 * np.pi ** 2 * BT ** 2 / np.log(2) * (n / float(Ns)) ** 2) + p = p / xp.sum(p) return p diff --git a/torchsig/datasets/wideband.py b/torchsig/datasets/wideband.py new file mode 100644 index 0000000..16ba992 --- /dev/null +++ b/torchsig/datasets/wideband.py @@ -0,0 +1,1241 @@ +import torch +import numpy as np +import pandas as pd +from tqdm import tqdm +from scipy import signal +from copy import deepcopy +from itertools import chain +from ast import literal_eval +from functools import partial +from typing import Tuple, Any, List, Optional, Callable, Union + +try: + import cusignal + import cupy as xp + CUSIGNAL = True + CUPY = True +except ImportError: + import numpy as cp + CUSIGNAL = False + CUPY = False + pass + +from torchsig.utils.dataset import SignalDataset +from torchsig.utils.types import SignalData, SignalDescription +from torchsig.datasets.synthetic import OFDMDataset, ConstellationDataset, FSKDataset +import torchsig.transforms as ST +from torchsig.transforms.functional import FloatParameter, NumericParameter +from torchsig.transforms.functional import to_distribution, uniform_continuous_distribution, uniform_discrete_distribution + + + +class SignalBurst(SignalDescription): + """SignalBurst is a class that inherits from the SignalDescription class but adds a + `generate_iq` method that should be implemented by subclasses in order to + generate the IQ for the signal described by the SignalDescription contents. + This class should be inherited to represent several kinds of burst + generation techniques. + + """ + def __init__(self, random_generator, **kwargs): + super(SignalBurst, self).__init__(**kwargs) + self.random_generator = random_generator + + def generate_iq(self): + # meant to be implemented by sub-class + raise NotImplementedError + + +class ShapedNoiseSignalBurst(SignalBurst): + """An SignalBurst which is just shaped (filtered) Gaussian noise + + Args: + **kwargs: + + """ + def __init__(self, **kwargs): + super(ShapedNoiseSignalBurst, self).__init__(**kwargs) + # Update freq values + self.lower_frequency = self.center_frequency - self.bandwidth / 2 + self.upper_frequency = self.center_frequency + self.bandwidth / 2 + + def generate_iq(self): + real_noise = self.random_generator.randn(int(self.num_iq_samples * self.duration)) + imag_noise = self.random_generator.randn(int(self.num_iq_samples * self.duration)) + iq_samples = real_noise + 1j * imag_noise + + # Precompute non-aliased low,upper,center,bw freqs + upper = 0.5 if self.upper_frequency > 0.5 else self.upper_frequency + lower = -0.5 if self.lower_frequency < -0.5 else self.lower_frequency + bandwidth = upper - lower + center = lower + bandwidth / 2 + + # Filter noise + num_taps = int(2*np.ceil(50*2*np.pi/bandwidth/.125/22)) # fred harris rule of thumb *2 + sinusoid = np.exp(2j * np.pi * center * np.linspace(0, num_taps - 1, num_taps)) + taps = signal.firwin( + num_taps, + bandwidth, + width=bandwidth * .02, + window=signal.get_window("blackman", num_taps), + scale=True + ) + taps = taps * sinusoid + iq_samples = signal.fftconvolve(iq_samples, taps, mode="same") + + # prune to be correct size out of filter + iq_samples = iq_samples[-int(self.num_iq_samples * self.duration):] + + # We ultimately want E_s/N_0 to be snr. We can also express this as: + # E_s/(N*B_n) -- N is noise energy per hertz and B_n is the noise bandwidth + # First, to get E_s = 1, we want E[abs(x)^2] = 1 + # Multiply by sqrt(mean(abs(x)^2)) so that mean(abs(x)^2) = 1 + iq_samples = iq_samples / np.sqrt(np.mean(np.abs(iq_samples) ** 2)) + + # Next, we assume that N_0 will be fixed at 1.0 because we will have something else add a uniform noise floor. + # Also, since B_n is the bandwidth of the noise that is in the same band as our signal, B_n = self.bandwidth + # Therefore, we multiply the signal by bandwidth so that we achieve E_s/N_0. + # Intuitively, we are reducing our signal power the smaller bandwidth we have since we will also have + # correspondingly less noise energy in the same band as our signal the smaller bandwidth the signal is. + # Then we multiply by sqrt(10^(snr/10.0)) (same as 10^(snr/20.0) to force our energy per hertz to be snr + iq_samples = np.sqrt(bandwidth) * (10 ** (self.snr / 20.0)) * iq_samples / np.sqrt(2) + + if iq_samples.shape[0] > 50: + window = np.blackman(50) / np.max(np.blackman(50)) + iq_samples[:25] *= window[:25] # burst-shape the front + iq_samples[-25:] *= window[-25:] # burst-shape the tail + + # zero-pad to fit num_iq_samples + leading_silence = int(self.num_iq_samples * self.start) + trailing_silence = self.num_iq_samples - len(iq_samples) - leading_silence + trailing_silence = 0 if trailing_silence < 0 else trailing_silence + + iq_samples = np.pad( + iq_samples, + pad_width=(leading_silence, trailing_silence), + mode="constant", + constant_values=0 + ) + # Prune if burst goes over + return iq_samples[:self.num_iq_samples] + + +class ModulatedSignalBurst(SignalBurst): + """A burst which is a shaped modulated signal + + Args: + modulation (:obj: `str`, `List[str]`) + The modulation or list of modulations to sample from for each burst + + modulation_list (:obj:`List[str]`): + The full list of modulations for mapping class names to indices + + **kwargs + + """ + def __init__( + self, + modulation: Union[str, List[str]] = None, + modulation_list: List[str] = None, + use_gpu: Optional[bool] = False, + **kwargs + ): + super(ModulatedSignalBurst, self).__init__(**kwargs) + self.use_gpu = use_gpu and torch.cuda.is_available() and CUPY and CUSIGNAL + # Read in full modulation list + default_class_list = [ + 'ook','bpsk','4pam','4ask','qpsk','8pam','8ask','8psk','16qam', + '16pam','16ask','16psk','32qam','32qam_cross','32pam','32ask', + '32psk','64qam','64pam','64ask','64psk','128qam_cross','256qam', + '512qam_cross','1024qam','2fsk','2gfsk','2msk','2gmsk','4fsk', + '4gfsk','4msk','4gmsk','8fsk','8gfsk','8msk','8gmsk','16fsk', + '16gfsk','16msk','16gmsk','ofdm-64','ofdm-72','ofdm-128', + 'ofdm-180','ofdm-256','ofdm-300','ofdm-512','ofdm-600','ofdm-900', + 'ofdm-1024','ofdm-1200','ofdm-2048' + ] + if modulation_list == "all" or modulation_list == None: + self.class_list = default_class_list + else: + self.class_list = modulation_list + + # Randomized classes to sample from + if modulation == "all" or modulation == None: + modulation = self.class_list + else: + modulation = [modulation] if isinstance(modulation, str) else modulation + self.classes = to_distribution( + modulation, + random_generator=self.random_generator, + ) + + # Update freq values + self.lower_frequency = self.center_frequency - self.bandwidth / 2 + self.upper_frequency = self.center_frequency + self.bandwidth / 2 + + def generate_iq(self): + # Read mod_index to determine which synthetic dataset to read from + self.class_name = self.classes() + self.class_index = self.class_list.index(self.class_name) + self.class_name = self.class_name if isinstance(self.class_name, list) else [self.class_name] + approx_samp_per_sym = int(np.ceil(self.bandwidth**-1)) if self.bandwidth < 1.0 else int(np.ceil(self.bandwidth)) + approx_bandwidth = approx_samp_per_sym**-1 if self.bandwidth < 1.0 else int(np.ceil(self.bandwidth)) + + # Determine if the new rate of the requested signal to determine how many samples to request + if "ofdm" in self.class_name[0]: + occupied_bandwidth = 0.5 + elif "g" in self.class_name[0]: + if "m" in self.class_name[0]: + occupied_bandwidth = approx_bandwidth * (1 - 0.5 + self.excess_bandwidth) + else: + occupied_bandwidth = approx_bandwidth * (1 + 0.25 + self.excess_bandwidth) + elif "fsk" in self.class_name[0]: + occupied_bandwidth = approx_bandwidth * (1 + 1) + elif "msk" in self.class_name[0]: + occupied_bandwidth = approx_bandwidth + else: + occupied_bandwidth = approx_bandwidth * (1 + self.excess_bandwidth) + new_rate = occupied_bandwidth / self.bandwidth + num_iq_samples = int(np.ceil(self.num_iq_samples*self.duration/new_rate*1.1)) + + # Create modulated burst + if "ofdm" in self.class_name[0]: + num_subcarriers = [int(self.class_name[0][5:])] + sidelobe_suppression_methods = ('lpf','win_start') + modulated_burst = OFDMDataset( + constellations=('bpsk', 'qpsk', '16qam', '64qam', '256qam', '1024qam'), # sub-carrier modulations + num_subcarriers=tuple(num_subcarriers), # possible number of subcarriers + num_iq_samples=num_iq_samples, + num_samples_per_class=1, + random_data=True, + sidelobe_suppression_methods=sidelobe_suppression_methods, + dc_subcarrier=('on', 'off'), + time_varying_realism=('on', 'off'), + use_gpu=self.use_gpu, + ) + elif "g" in self.class_name[0]: + modulated_burst = FSKDataset( + modulations=self.class_name, + num_iq_samples=num_iq_samples, + num_samples_per_class=1, + iq_samples_per_symbol=approx_samp_per_sym, + random_data=True, + random_pulse_shaping=True, + use_gpu=self.use_gpu, + ) + elif "fsk" in self.class_name[0] or "msk" in self.class_name[0]: + modulated_burst = FSKDataset( + modulations=self.class_name, + num_iq_samples=num_iq_samples, + num_samples_per_class=1, + iq_samples_per_symbol=approx_samp_per_sym, + random_data=True, + random_pulse_shaping=False, + use_gpu=self.use_gpu, + ) + else: + modulated_burst = ConstellationDataset( + constellations=self.class_name, + num_iq_samples=num_iq_samples, + num_samples_per_class=1, + iq_samples_per_symbol=approx_samp_per_sym, + random_data=True, + random_pulse_shaping=True, + use_gpu=self.use_gpu, + ) + + # Extract IQ samples from dataset example + iq_samples = modulated_burst[0][0] + + # Resample to target bandwidth * oversample to avoid freq wrap during shift + if self.center_frequency + self.bandwidth / 2 > 0.4 or self.center_frequency - self.bandwidth / 2 < -0.4: + oversample = 2 if self.bandwidth < 1.0 else int(np.ceil(self.bandwidth * 2)) + else: + oversample = 1 + up_rate = np.floor(new_rate * 100 * oversample).astype(np.int32) + down_rate = 100 + xp = cp if self.use_gpu else np + if self.use_gpu: + iq_samples = cusignal.resample_poly(xp.array(iq_samples), up_rate, down_rate) + else: + iq_samples = signal.resample_poly(iq_samples, up_rate, down_rate) + + # Freq shift to desired center freq + time_vector = xp.arange(iq_samples.shape[0], dtype=float) + iq_samples = iq_samples * xp.exp(2j * np.pi * self.center_frequency/oversample * time_vector) + + if oversample == 1: + # Prune to length + iq_samples = iq_samples[-int(self.num_iq_samples*self.duration):] + else: + # Pre-prune to reduce filtering cost + iq_samples = iq_samples[-int(self.num_iq_samples*self.duration*oversample):] + + # Filter around center + num_taps = int(2*np.ceil(50*2*np.pi/0.5/.125/22)) # fred harris rule of thumb * 2 + if self.use_gpu: + taps = cusignal.firwin( + num_taps, + 1/oversample, + width=1/oversample * .02, + window=signal.get_window("blackman", num_taps), + scale=True + ) + iq_samples = xp.convolve(xp.array(iq_samples), xp.array(taps), mode="same") + # Decimate back down to correct sample rate + iq_samples = cusignal.resample_poly(xp.array(iq_samples), 1, oversample) + iq_samples = iq_samples[-int(self.num_iq_samples*self.duration):] + else: + taps = signal.firwin( + num_taps, + 1/oversample, + width=1/oversample * .02, + window=signal.get_window("blackman", num_taps), + scale=True + ) + iq_samples = np.convolve(iq_samples, taps, mode="same") + + # Decimate back down to correct sample rate + iq_samples = signal.resample_poly(iq_samples, 1, oversample) + iq_samples = iq_samples[-int(self.num_iq_samples*self.duration):] + + # Set power + iq_samples = iq_samples/xp.sqrt(xp.mean(xp.abs(iq_samples)**2)) + iq_samples = xp.sqrt(self.bandwidth)*(10**(self.snr/20.0))*iq_samples/xp.sqrt(2) + + if iq_samples.shape[0] > 50: + window = xp.blackman(50)/xp.max(xp.blackman(50)) + iq_samples[:25] *= window[:25] + iq_samples[-25:] *= window[-25:] + + # Zero-pad to fit num_iq_samples + leading_silence = int(self.num_iq_samples*self.start) + trailing_silence = self.num_iq_samples - len(iq_samples) - leading_silence + trailing_silence = 0 if trailing_silence < 0 else trailing_silence + + iq_samples = xp.pad( + xp.array(iq_samples), + pad_width=(leading_silence, trailing_silence), + mode="constant", + constant_values=0 + ) + + iq_samples = xp.asnumpy(iq_samples) if self.use_gpu else iq_samples + + return iq_samples[:self.num_iq_samples] + + +class SignalOfInterestSignalBurst(SignalBurst): + """A burst which is a generic class, reading in its IQ generation function + + Args: + soi_gen_iq: (:obj: `Callable`): + A function that generates the SOI's IQ data. Note that in order for + the randomized bandwidths to function with the + `SyntheticBurstSource`, the generation function must input a + bandwidth argument. + + soi_gen_bw: (:obj:`float`): + A float parameter informing the `SignalOfInterestSignalBurst` object + what the SOI's bandwidth was generated at within the `soi_gen_iq` + function. Defaults to 0.5, signifying half-bandwidth or 2x over- + sampled generation, which is sufficient for most signals. + + soi_class: (:obj:`str`): + The class of the SOI + + soi_class_list: (:obj:`List[str]`): + The class list from which the SOI belongs + + **kwargs + + """ + def __init__( + self, + soi_gen_iq: Callable = None, + soi_gen_bw: float = 0.5, + soi_class: str = None, + soi_class_list: List[str] = None, + **kwargs + ): + super(SignalOfInterestSignalBurst, self).__init__(**kwargs) + self.soi_gen_iq = soi_gen_iq + self.soi_gen_bw = soi_gen_bw + self.class_name = soi_class if soi_class else 'soi0' + self.class_list = soi_class_list if soi_class_list else ['soi0'] + self.class_index = self.class_list.index(self.class_name) + self.lower_frequency = self.center_frequency - self.bandwidth / 2 + self.upper_frequency = self.center_frequency + self.bandwidth / 2 + + def generate_iq(self): + # Generate the IQ from the provided SOI generator + iq_samples = self.soi_gen_iq() + + # Resample to target bandwidth * 2 to avoid freq wrap during shift + new_rate = self.soi_gen_bw / self.bandwidth + up_rate = np.floor(new_rate * 100 * 2).astype(np.int32) + down_rate = 100 + iq_samples = signal.resample_poly(iq_samples, up_rate, down_rate) + + # Freq shift to desired center freq + time_vector = np.arange(iq_samples.shape[0], dtype=float) + iq_samples = iq_samples * np.exp(2j * np.pi * self.center_frequency/2 * time_vector) + + # Filter around center + num_taps = int(2*np.ceil(50*2*np.pi/0.5/.125/22)) # fred harris rule of thumb * 2 + taps = signal.firwin( + num_taps, + 0.5, + width=0.5 * .02, + window=signal.get_window("blackman", num_taps), + scale=True + ) + iq_samples = signal.fftconvolve(iq_samples, taps, mode="same") + + # Decimate back down to correct sample rate + iq_samples = signal.resample_poly(iq_samples, 1, 2) + iq_samples = iq_samples[-int(self.num_iq_samples*self.duration):] + + # Set power + iq_samples = iq_samples/np.sqrt(np.mean(np.abs(iq_samples)**2)) + iq_samples = np.sqrt(self.bandwidth)*(10**(self.snr/20.0))*iq_samples/np.sqrt(2) + + if iq_samples.shape[0] > 50: + window = np.blackman(50)/np.max(np.blackman(50)) + iq_samples[:25] *= window[:25] + iq_samples[-25:] *= window[-25:] + + # Zero-pad to fit num_iq_samples + leading_silence = int(self.num_iq_samples*self.start) + trailing_silence = self.num_iq_samples - len(iq_samples) - leading_silence + trailing_silence = 0 if trailing_silence < 0 else trailing_silence + + iq_samples = np.pad( + iq_samples, + pad_width=(leading_silence, trailing_silence), + mode="constant", + constant_values=0 + ) + return iq_samples[:self.num_iq_samples] + + +class FileSignalBurst(SignalBurst): + """A burst which reads previously-extracted bursts from individual files + that contain the IQ data for each burst. + + Args: + file_path (:obj: `str`, :obj:`list`): + Specify the file path from which to read the IQ data + * If string, file_path is fixed at the value provided + * If list, file_path is randomly sampled from the input list + + file_reader (:obj: `Callable`): + A function that instructs the `FileSignalBurst` class how to read the + IQ data from the file(s) along with the class name and occupied + bandwidth within the file + + class_list (:obj: `List[str]`): + A list of classes to map the read class name to the respective + class index + + **kwargs + + """ + def __init__( + self, + file_path: Union[str, List] = None, + file_reader: Callable = None, + class_list: List[str] = None, + **kwargs + ): + super(FileSignalBurst, self).__init__(**kwargs) + self.file_path = to_distribution( + file_path, + random_generator=self.random_generator, + ) + self.file_reader = file_reader + self.class_list = class_list + self.lower_frequency = self.center_frequency - self.bandwidth / 2 + self.upper_frequency = self.center_frequency + self.bandwidth / 2 + + def generate_iq(self): + # Read the IQ from the file_path using the file_reader + file_path = self.file_path if isinstance(self.file_path, str) else self.file_path() + iq_samples, class_name, file_bw = self.file_reader(file_path) + + # Assign read class information to SignalBurst + self.class_name = class_name + self.class_index = self.class_list.index(self.class_name) + + # Resample to target bandwidth * 2 to avoid freq wrap during shift + new_rate = file_bw / self.bandwidth + up_rate = np.floor(new_rate * 100 * 2).astype(np.int32) + down_rate = 100 + iq_samples = signal.resample_poly(iq_samples, up_rate, down_rate) + + # Freq shift to desired center freq + time_vector = np.arange(iq_samples.shape[0], dtype=float) + iq_samples = iq_samples * np.exp(2j * np.pi * self.center_frequency/2 * time_vector) + + # Filter around center + num_taps = int(2*np.ceil(50*2*np.pi/0.5/.125/22)) # fred harris rule of thumb * 2 + taps = signal.firwin( + num_taps, + 0.5, + width=0.5 * .02, + window=signal.get_window("blackman", num_taps), + scale=True + ) + iq_samples = signal.fftconvolve(iq_samples, taps, mode="same") + + # Decimate back down to correct sample rate + iq_samples = signal.resample_poly(iq_samples, 1, 2) + + # Inspect/set duration + if iq_samples.shape[0] < self.num_iq_samples*self.duration: + self.duration = iq_samples.shape[0] / self.num_iq_samples + self.stop = self.start + self.duration + iq_samples = iq_samples[-int(self.num_iq_samples*self.duration):] + + # Set power + iq_samples = iq_samples/np.sqrt(np.mean(np.abs(iq_samples)**2)) + iq_samples = np.sqrt(self.bandwidth)*(10**(self.snr/20.0))*iq_samples/np.sqrt(2) + + if iq_samples.shape[0] > 50: + window = np.blackman(50)/np.max(np.blackman(50)) + iq_samples[:25] *= window[:25] + iq_samples[-25:] *= window[-25:] + + # Zero-pad to fit num_iq_samples + leading_silence = int(self.num_iq_samples*self.start) + trailing_silence = self.num_iq_samples - len(iq_samples) - leading_silence + trailing_silence = 0 if trailing_silence < 0 else trailing_silence + + iq_samples = np.pad( + iq_samples, + pad_width=(leading_silence, trailing_silence), + mode="constant", + constant_values=0 + ) + return iq_samples[:self.num_iq_samples] + + +class BurstSourceDataset(SignalDataset): + """Abstract Base Class for sources of bursts. + + Args: + num_iq_samples (int, optional): [description]. Defaults to 512*512. + num_samples (int, optional): [description]. Defaults to 100. + + """ + def __init__( + self, + num_iq_samples: int = 512 * 512, + num_samples: int = 1000, + **kwargs + ): + super(BurstSourceDataset, self).__init__(**kwargs) + self.num_iq_samples = num_iq_samples + self.num_samples = num_samples + + def __getitem__(self, item: int) -> Tuple[np.ndarray, Any]: + burst_collection = self.index[item][0] + iq_samples = np.zeros((self.num_iq_samples,), dtype=np.complex128) + for burst_idx, burst in enumerate(burst_collection): + iq_samples += burst.generate_iq() + + # Format into single SignalData object + signal_data = SignalData( + data=iq_samples.tobytes(), + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=burst_collection, + ) + + # Apply transforms + signal_data = self.transform(signal_data) if self.transform else signal_data + target = self.target_transform(signal_data.signal_description) if self.target_transform else signal_data.signal_description + iq_data = signal_data.iq_data + + return iq_data, target + + def __len__(self) -> int: + return len(self.index) + + +class SyntheticBurstSourceDataset(BurstSourceDataset): + """ SyntheticBurstSourceDataset is a Dataset that is meant to represent a set of bursts presumably coming from the same + or similar kinds of sources. It could represent a single Wi-Fi or bluetooth device, for example. This was made + so that it could be its own dataset, if necessary. + + """ + def __init__( + self, + bandwidths: FloatParameter = uniform_continuous_distribution(.01, .1), + center_frequencies: FloatParameter = uniform_continuous_distribution(-.25, .25), + burst_durations: FloatParameter = uniform_continuous_distribution(.2, .2), + silence_durations: FloatParameter = uniform_continuous_distribution(.01, .3), + snrs_db: NumericParameter = uniform_discrete_distribution(range(-5, 15)), + start: FloatParameter = uniform_continuous_distribution(0.0, 0.9), + burst_class: SignalBurst = None, + num_iq_samples: int = 512*512, + num_samples: int = 20, + seed: Optional[int] = None, + use_gpu: Optional[bool] = False, + **kwargs + ): + super(SyntheticBurstSourceDataset, self).__init__(**kwargs) + self.random_generator = np.random.RandomState(seed) + self.num_iq_samples = num_iq_samples + self.num_samples = num_samples + self.burst_class = burst_class + self.use_gpu = use_gpu and torch.cuda.is_available() and CUPY and CUSIGNAL + self.bandwidths = to_distribution(bandwidths, random_generator=self.random_generator) + self.center_frequencies = to_distribution(center_frequencies, random_generator=self.random_generator) + self.burst_durations = to_distribution(burst_durations, random_generator=self.random_generator) + self.silence_durations = to_distribution(silence_durations, random_generator=self.random_generator) + self.snrs_db = to_distribution(snrs_db, random_generator=self.random_generator) + self.start = to_distribution(start, random_generator=self.random_generator) + + # Generate the index by creating a set of bursts. + self.index = [(collection, idx) for idx, collection in enumerate(self._generate_burst_collections())] + + def _generate_burst_collections(self) -> List[List[SignalBurst]]: + dataset = [] + for sample_idx in range(self.num_samples): + sample_burst_collection = [] + start = self.start() + while start < 0.95: # Avoid bursts of durations < 0.05 at end + burst_duration = self.burst_durations() + silence_duration = self.silence_durations() + center_frequency = self.center_frequencies() + bandwidth = self.bandwidths() + snr = self.snrs_db() + + # Boundary checks + stop = start + burst_duration + if stop > 1.0: + burst_duration = 1.0 - start + + sample_burst_collection.append( + self.burst_class( + num_iq_samples=self.num_iq_samples, + start=0 if start < 0 else start, + stop=start + burst_duration, + center_frequency=center_frequency, + bandwidth=bandwidth, + snr=snr, + random_generator=self.random_generator, + use_gpu=self.use_gpu, + ) + ) + start = start + burst_duration + silence_duration + dataset.append(sample_burst_collection) + return dataset + + +class WidebandDataset(SignalDataset): + """WidebandDataset is an SignalDataset that contains several SignalSourceDataset + objects. Each sample from this dataset includes bursts from each contained + SignalSourceDataset as well as a collection of SignalDescriptions which + includes all meta-data about the bursts. + + Args: + signal_sources (:obj:`list` of :py:class:`SignalSource`): + List of SignalSource objects from which to sample bursts and add to an overall signal + + num_iq_samples (:obj:`int`): + number of IQ samples to produce + + num_samples (:obj:`int`): + number of dataset samples to produce + + transform (:class:`Callable`, optional): + A function/transform that takes in an IQ vector and returns a transformed version. + + """ + def __init__( + self, + signal_sources: List[BurstSourceDataset], + num_iq_samples: int, + num_samples: int, + pregenerate: bool = False, + **kwargs + ): + super(WidebandDataset, self).__init__(**kwargs) + self.signal_sources = signal_sources + self.num_iq_samples = num_iq_samples + self.num_samples = num_samples + + self.index = [] + self.pregenerate = False + if pregenerate: + print("Pregenerating dataset...") + for idx in tqdm(range(self.num_samples)): + self.index.append(self.__getitem__(idx)) + self.pregenerate = pregenerate + + def __getitem__(self, item: int) -> Tuple[np.ndarray, Any]: + if self.pregenerate: + return self.index[item] + # Retrieve data & metadata from all signal sources + iq_data = None + signal_description_collection = [] + for source_idx in range(len(self.signal_sources)): + signal_iq_data, signal_description = self.signal_sources[source_idx][item] + iq_data = signal_iq_data if iq_data is None else iq_data + signal_iq_data + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + signal_description_collection.extend(signal_description) + + # Format into single SignalData object + signal_data = SignalData( + data=iq_data.tobytes(), + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=signal_description_collection, + ) + + # Apply transforms + signal_data = self.transform(signal_data) if self.transform else signal_data + target = self.target_transform(signal_data.signal_description) if self.target_transform else signal_data.signal_description + iq_data = signal_data.iq_data + + return iq_data, target + + def __len__(self) -> int: + return self.num_samples + + +class WidebandModulationsDataset(SignalDataset): + """The `WidebandModulationsDataset` is an `SignalDataset` that creates + multiple, non-overlapping, realistic wideband modulated signals whenever + a data sample is requested. The `__gen_metadata__` method is responsible + for any inter-modulation relationships, currently hard-coded such that OFDM + signals are handled differently than the remaining modulations. + + Args: + modulation_list (:obj: `List[str]`): + The list of modulations to include in the wideband samples + + level (:obj: `int`): + Set the difficulty level of the dataset with levels 0-2 + + num_iq_samples (:obj: `int`): + Set the requested number of IQ samples for each dataset example + + num_samples (:obj: `int`): + Set the number of samples for the dataset to contain + + transform (:class:`Callable`, optional): + A function/transform that takes in an IQ vector and returns a transformed version. + + target_transform (:class:`Callable`, optional): + A function/transform that takes in a list of SignalDescription objects and returns a transformed target. + + seed (:obj: `int`, optional): + A seed for reproducibility + + use_gpu (:obj: `bool`, optional): + A boolean specifying whether generation should leverage the GPU for faster processing + + **kwargs + + """ + default_modulations = [ + 'ook','bpsk','4pam','4ask','qpsk','8pam','8ask','8psk','16qam','16pam', + '16ask','16psk','32qam','32qam_cross','32pam','32ask','32psk','64qam', + '64pam','64ask','64psk','128qam_cross','256qam','512qam_cross', + '1024qam','2fsk','2gfsk','2msk','2gmsk','4fsk','4gfsk','4msk','4gmsk', + '8fsk','8gfsk','8msk','8gmsk','16fsk','16gfsk','16msk','16gmsk', + 'ofdm-64','ofdm-72','ofdm-128','ofdm-180','ofdm-256','ofdm-300', + 'ofdm-512','ofdm-600','ofdm-900','ofdm-1024','ofdm-1200','ofdm-2048', + ] + + def __init__( + self, + modulation_list: List = None, + level: int = 0, + num_iq_samples: int = 262144, + num_samples: int = 10, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + seed: Optional[int] = None, + use_gpu: Optional[bool] = True, + **kwargs, + ): + super(WidebandModulationsDataset, self).__init__(**kwargs) + self.random_generator = np.random.RandomState(seed) + self.seed = seed + self.modulation_list = self.default_modulations if modulation_list is None else modulation_list + self.metadata = self.__gen_metadata__(self.modulation_list) + self.num_modulations = len(self.metadata) + # Bump up OFDM ratio slightly due to its higher bandwidth and lack of bursty nature + # This helps make the number of OFDM signals closer to the others + self.ofdm_ratio = (self.num_ofdm / self.num_modulations) * 2.0 + self.num_iq_samples = num_iq_samples + self.num_samples = num_samples + self.use_gpu = use_gpu and torch.cuda.is_available() and CUPY and CUSIGNAL + + # Set level-specific parameters + if level == 0: + num_signals = (1,1) + snrs = (40,40) + self.transform = ST.Compose([ + ST.AddNoise(noise_power_db=(0,0), input_noise_floor_db=-100), # Set input noise floor very low because this transform sets the floor + ST.Normalize(norm=np.inf), + ]) + elif level == 1: + num_signals = (1,6) + snrs = (20,40) + self.transform = ST.Compose([ + ST.AddNoise(noise_power_db=(0,0), input_noise_floor_db=-100), # Set input noise floor very low because this transform sets the floor + ST.AddNoise(noise_power_db=(-40,-20), input_noise_floor_db=0), # Then add minimal noise without affecting SNR + ST.Normalize(norm=np.inf), + ]) + elif level == 2: + num_signals = (1,6) + snrs = (0,30) + self.transform = ST.Compose([ + ST.RandomApply(ST.RandomTimeShift(shift=(-int(num_iq_samples/2),int(num_iq_samples/2))),0.25), + ST.RandomApply(ST.RandomFrequencyShift(freq_shift=(-0.2,0.2)),0.25), + ST.RandomApply(ST.RandomResample(rate_ratio=(0.8,1.2), num_iq_samples=num_iq_samples),0.25), + ST.RandomApply(ST.SpectralInversion(),0.5), + ST.AddNoise(noise_power_db=(0,0), input_noise_floor_db=-100), # Set input noise floor very low because this transform sets the floor + ST.AddNoise(noise_power_db=(-40,-20), input_noise_floor_db=0), # Then add minimal noise without affecting SNR + ST.RandAugment([ + ST.RandomApply(ST.RandomMagRescale(start=(0,0.9), scale=(-4,4)),0.5), + ST.RollOff( + low_freq=(0.00,0.05), + upper_freq=(0.95,1.00), + low_cut_apply=0.5, + upper_cut_apply=0.5, + order=(6,20) + ), + ST.RandomConvolve(num_taps=(2,5), alpha=(0.1,0.4)), + ST.RayleighFadingChannel((0.0004,0.0005)), + ST.RandomDropSamples(drop_rate=0.01, size=(1,1), fill=['ffill', 'bfill', 'mean', 'zero']), + ST.RandomPhaseShift((-1, 1)), + ST.IQImbalance((-3, 3), (-np.pi*1.0/180.0, np.pi*1.0/180.0), (-.1, .1)), + ], num_transforms=2 + ), + ST.Normalize(norm=np.inf), + ]) + else: + raise ValueError("Input level expected to be either 0, 1, or 2. Found {}".format(self.level)) + + if transform is not None: + self.transform = ST.Compose([ + self.transform, + transform, + ]) + self.target_transform = target_transform + + self.num_signals = to_distribution(num_signals, random_generator=self.random_generator) + self.snrs = to_distribution(snrs, random_generator=self.random_generator) + + + def __gen_metadata__(self, modulation_list: List) -> pd.DataFrame: + """This method defines the parameters of the modulations to be inserted + into the wideband data. The values below are hardcoded; however, if + new datasets are desired with different modulation relationships, the + below data can be parameterized or updated to new values. + + """ + self.num_ofdm = 0 + column_names = [ + "index", + "modulation", + "bursty_prob", + "burst_duration", + "silence_multiple", + "freq_hopping_prob", + "freq_hopping_channels", + ] + metadata = [] + for index, modulation in enumerate(modulation_list): + if "ofdm" in modulation: + self.num_ofdm += 1 + bursty_prob = 0.0 + burst_duration = "(0.05,0.10)" + silence_multiple = "(1,1)" + freq_hopping_prob = 0.0 + freq_hopping_channels = "(1,1)" + else: + bursty_prob = 0.2 + burst_duration = "(0.05,0.20)" + silence_multiple = "(1,3)" + freq_hopping_prob = 0.2 + freq_hopping_channels = "(2,16)" + + metadata.append([ + index, + modulation, + bursty_prob, + burst_duration, + silence_multiple, + freq_hopping_prob, + freq_hopping_channels, + ]) + + return pd.DataFrame(metadata, columns=column_names) + + def __getitem__(self, item: int) -> Tuple[np.ndarray, Any]: + # Initialize empty list of signal sources & signal descriptors + signal_sources = [] + modulations = [] + + # Randomly decide how many signals in capture + num_signals = int(self.num_signals()) + + # Randomly decide if OFDM signals are in capture + ofdm_present = True if self.random_generator.rand() < self.ofdm_ratio else False + + # Loop through signals to add + sig_counter = 0 + overlap_counter = 0 + while sig_counter < num_signals and overlap_counter < 5: + if ofdm_present: + if sig_counter == 0: + # Randomly sample from OFDM options (assumes OFDM at end) + meta_idx = self.random_generator.randint(self.num_modulations - self.num_ofdm, self.num_modulations) + modulation = self.metadata.iloc[meta_idx].modulation + else: + # Randomly select signal from full metadata list + meta_idx = self.random_generator.randint(self.num_modulations) + modulation = self.metadata.iloc[meta_idx].modulation + else: + # Randomly sample from all but OFDM (assumes OFDM at end) + meta_idx = self.random_generator.randint(self.num_modulations - self.num_ofdm) + modulation = self.metadata.iloc[meta_idx].modulation + + # Random bandwidth based on signal modulation and num_signals + if ofdm_present: + if "ofdm" in modulation: + if num_signals == 1: + bandwidth = self.random_generator.uniform(0.2, 0.7) + else: + bandwidth = self.random_generator.uniform(0.3, 0.5) + else: + bandwidth = self.random_generator.uniform(0.025, 0.1) + else: + if num_signals == 1: + bandwidth = self.random_generator.uniform(0.05, 0.4) + else: + bandwidth = self.random_generator.uniform(0.05,0.15) + + # Random center frequency + center_freq = self.random_generator.uniform(-0.4,0.4) + + # Determine if continuous or bursty + burst_random_var = self.random_generator.rand() + hop_random_var = self.random_generator.rand() + if burst_random_var < self.metadata.iloc[meta_idx].bursty_prob or hop_random_var < self.metadata.iloc[meta_idx].freq_hopping_prob: + # Signal is bursty + bursty = True + burst_duration = to_distribution(literal_eval(self.metadata.iloc[meta_idx].burst_duration), random_generator=self.random_generator)() + silence_multiple = to_distribution(literal_eval(self.metadata.iloc[meta_idx].silence_multiple), random_generator=self.random_generator)() + stops_in_frame = False + if hop_random_var < self.metadata.iloc[meta_idx].freq_hopping_prob: + # override bandwidth with smaller options for freq hoppers + if ofdm_present: + bandwidth = self.random_generator.uniform(0.0125, 0.025) + else: + bandwidth = self.random_generator.uniform(0.025, 0.05) + + silence_duration = burst_duration * (silence_multiple - 1) + freq_channels = to_distribution(literal_eval(self.metadata.iloc[meta_idx].freq_hopping_channels), random_generator=self.random_generator)() + + # Convert channel count to list of center frequencies + center_freq = np.arange(center_freq, center_freq+(bandwidth*freq_channels), bandwidth) + center_freq = (center_freq - (freq_channels/2*bandwidth)) + center_freq = center_freq[center_freq < 0.5] + center_freq = center_freq[center_freq > -0.5] + center_freq = center_freq.tolist() + if len(center_freq) == 1 and silence_duration == 0: + # If all but one band outside freq range, ensure nonzero silence duration + silence_duration = burst_duration + + low_freq = min(center_freq) - bandwidth/2 + high_freq = max(center_freq) + bandwidth/2 + + else: + silence_duration = burst_duration * silence_multiple + low_freq = center_freq - bandwidth/2 + high_freq = center_freq + bandwidth/2 + + else: + # Signal is continous + bursty = False + burst_duration = 1.0 + silence_duration = 1.0 + low_freq = center_freq - bandwidth/2 + high_freq = center_freq + bandwidth/2 + + # Randomly determine if the signal should stop in the frame + if self.random_generator.rand() < 0.2: + stops_in_frame = True + burst_duration = self.random_generator.uniform(0.05,0.95) + else: + stops_in_frame = False + + # Randomly determine if the signal should start in the frame + if self.random_generator.rand() < 0.2 and not stops_in_frame: + start = self.random_generator.uniform(0,0.95) + stop = 1.0 + else: + start = 0.0 + stop = burst_duration + if bursty: + start = start + self.random_generator.rand() * burst_duration + stop = 1.0 + + # Handle overlaps + overlap = False + minimum_freq_spacing = 0.05 + for source in signal_sources: + for signal in source.index[0][0]: + # Check time overlap + if (start > signal.start and start < signal.stop) or \ + (start + burst_duration > signal.stop and stop < signal.stop) or \ + (signal.start > start and signal.start < stop) or \ + (signal.stop > start and signal.stop < stop) or \ + (start == 0.0 and signal.start == 0.0) or (stop == 1.0 and signal.stop == 1.0): + # Check freq overlap + if (low_freq > signal.lower_frequency - minimum_freq_spacing and low_freq < signal.upper_frequency + minimum_freq_spacing) or \ + (high_freq > signal.lower_frequency - minimum_freq_spacing and high_freq < signal.upper_frequency + minimum_freq_spacing) or \ + (signal.lower_frequency - minimum_freq_spacing > low_freq and signal.lower_frequency - minimum_freq_spacing < high_freq) or \ + (signal.upper_frequency + minimum_freq_spacing > low_freq and signal.upper_frequency + minimum_freq_spacing < high_freq): + # Overlaps in both time and freq, skip + overlap = True + if overlap: + overlap_counter += 1 + continue + + # Add signal to signal sources + signal_sources.append( + SyntheticBurstSourceDataset( + bandwidths=bandwidth, + center_frequencies=center_freq, + burst_durations=burst_duration, + silence_durations=silence_duration, + snrs_db=self.snrs(), + start=start, + burst_class=partial( + ModulatedSignalBurst, + modulation=modulation, + modulation_list=self.modulation_list, + ), + num_iq_samples=self.num_iq_samples, + num_samples=1, + transform=None, + seed=self.seed+item*53 if self.seed else None, + use_gpu=self.use_gpu, + ), + ) + sig_counter += 1 + + iq_data = None + signal_description_collection = [] + for source_idx in range(len(signal_sources)): + signal_iq_data, signal_description = signal_sources[source_idx][0] + iq_data = signal_iq_data if iq_data is None else iq_data + signal_iq_data + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + signal_description_collection.extend(signal_description) + + # If no signal sources present, add noise + if iq_data is None: + real_noise = np.random.randn(self.num_iq_samples,) + imag_noise = np.random.randn(self.num_iq_samples,) + iq_data = real_noise + 1j*imag_noise + + # Format into single SignalData object + signal_data = SignalData( + data=iq_data.tobytes(), + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=signal_description_collection, + ) + + # Apply transforms + signal_data = self.transform(signal_data) if self.transform else signal_data + target = self.target_transform(signal_data.signal_description) if self.target_transform else signal_data.signal_description + iq_data = signal_data.iq_data + + return iq_data, target + + def __len__(self) -> int: + return self.num_samples + + +class Interferers(ST.SignalTransform): + """SignalTransform that inputs burst sources to add as unlabeled interferers + + Args: + burst_sources :obj:`BurstSourceDataset`: + Burst source dataset defining interferers to be added + + num_iq_samples :obj:`int`: + Number of IQ samples in requested dataset & interferer examples + + num_samples :obj:`int`: + Number of unique interfer examples + + interferer_transform :obj:`SignalTransform`: + SignalTransforms to be applied to the interferers + + """ + def __init__( + self, + burst_sources: 'BurstSourceDataset' = None, + num_iq_samples: int = 262144, + num_samples: int = 10, + interferer_transform: ST.SignalTransform = None, + ): + super(Interferers, self).__init__() + self.num_samples = num_samples + self.interferers = WidebandDataset( + signal_sources=burst_sources, + num_iq_samples=num_iq_samples, + num_samples=self.num_samples, + transform=interferer_transform, + target_transform=None, + ) + + def __call__(self, data: Any) -> Any: + idx = np.random.randint(self.num_samples) + if isinstance(data, SignalData): + data.iq_data = data.iq_data + self.interferers[idx][0] + else: + data = data + self.interferers[idx][0] + return data + + +class RandomSignalInsertion(ST.SignalTransform): + """RandomSignalInsertion reads the input SignalData's occupied frequency + bands from the SignalDescription objects and then randomly generates and + inserts a new continuous or bursty single carrier signal into a randomly + selected unoccupied frequency band, such that no signal overlap occurs + + Args: + modulation_list :obj:`list`: + Optionally pass in a list of modulations to sample from for the + inserted signal. If None or omitted, the default full list of + modulations will be used. + + """ + default_modulation_list = [ + "ook","bpsk","4pam","4ask","qpsk","8pam","8ask","8psk","16qam","16pam", + "16ask","16psk","32qam","32qam_cross","32pam","32ask","32psk","64qam","64pam","64ask", + "64psk","128qam_cross","256qam","512qam_cross","1024qam","2fsk","2gfsk","2msk","2gmsk","4fsk", + "4gfsk","4msk","4gmsk","8fsk","8gfsk","8msk","8gmsk","16fsk","16gfsk","16msk","16gmsk", + "ofdm-64","ofdm-72","ofdm-128","ofdm-180","ofdm-256","ofdm-300","ofdm-512","ofdm-600", + "ofdm-900","ofdm-1024","ofdm-1200","ofdm-2048", + ] + def __init__(self, modulation_list: list = None): + super(RandomSignalInsertion, self).__init__() + self.modulation_list = modulation_list if modulation_list else self.default_modulation_list + + def __call__(self, data: Any) -> Any: + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=[], + ) + num_iq_samples = data.iq_data.shape[0] + + # Read existing SignalDescription for unoccupied freq bands + new_signal_description = deepcopy(data.signal_description) + new_signal_description = [new_signal_description] if isinstance(new_signal_description, SignalDescription) else new_signal_description + occupied_bands = [] + for new_signal_desc in new_signal_description: + occupied_bands.append([int((new_signal_desc.lower_frequency+0.5)*100), int((new_signal_desc.upper_frequency+0.5)*100)]) + occupied_bands = sorted(occupied_bands) + flat = chain((0-1,), chain.from_iterable(occupied_bands), (100+1,)) + unoccupied_bands = [((x+1)/100-0.5, (y-1)/100-0.5) for x, y in zip(flat, flat) if x+6 < y] + if len(unoccupied_bands) > 0: + max_bandwidth = min([y-x for x, y in unoccupied_bands]) + bandwidth = np.random.uniform(0.05, max_bandwidth) + center_freqs = [(x+bandwidth/2,y-bandwidth/2) for x, y in unoccupied_bands] + center_freqs = to_distribution(center_freqs) + center_freq = center_freqs() + bursty = True if np.random.rand() < 0.5 else False + burst_duration = np.random.uniform(0.05,1.0) if bursty else 1.0 + silence_duration = burst_duration if bursty else 1.0 + if bandwidth < 0.2: + modulation_list = [] + for mod in self.modulation_list: + if "ofdm" not in mod: + modulation_list.append(mod) + else: + modulation_list = self.modulation_list + num_samples = int(1/burst_duration + 2) if bursty else 1 + + signal_sources = [ + SyntheticBurstSourceDataset( + bandwidths=bandwidth, + center_frequencies=center_freq, + burst_durations=burst_duration, + silence_durations=silence_duration, + snrs_db=20, + start=(-0.05,0.95), + burst_class=partial( + ModulatedSignalBurst, + modulation=modulation_list, + modulation_list=modulation_list, + ), + num_iq_samples=num_iq_samples, + num_samples=num_samples, + transform=None, + ), + ] + signal_dataset = WidebandDataset( + signal_sources=signal_sources, + num_iq_samples=num_iq_samples, + num_samples=num_samples, + transform=ST.Normalize(norm=np.inf), + target_transform=None, + ) + + new_signal_data, new_signal_signal_desc = signal_dataset[0] + new_data.iq_data = data.iq_data + new_signal_data + + # Update the SignalDescription + new_signal_description.extend(new_signal_signal_desc) + new_data.signal_description = new_signal_description + + else: + new_data.iq_data = data.iq_data + + else: + num_iq_samples = data.shape[0] + num_samples = int(1/0.05 + 2) + signal_sources = [ + SyntheticBurstSourceDataset( + bandwidths=(0.05,0.8), + center_frequencies=(-0.4,0.4), + burst_durations=(0.05,1.0), + silence_durations=(0.05,1.0), + snrs_db=20, + start=(-0.05,0.95), + burst_class=partial( + ModulatedSignalBurst, + modulation=self.modulation_list, + modulation_list=self.modulation_list, + ), + num_iq_samples=num_iq_samples, + num_samples=num_samples, + transform=None, + ), + ] + signal_dataset = WidebandDataset( + signal_sources=signal_sources, + num_iq_samples=num_iq_samples, + num_samples=num_samples, + transform=ST.Normalize(norm=np.inf), + target_transform=None, + ) + new_data = data + signal_dataset[0][0] + + return new_data diff --git a/torchsig/datasets/wideband_sig53.py b/torchsig/datasets/wideband_sig53.py new file mode 100644 index 0000000..7ddd2b5 --- /dev/null +++ b/torchsig/datasets/wideband_sig53.py @@ -0,0 +1,204 @@ +import os +import lmdb +import pickle +import shutil +import numpy as np +from pathlib import Path +from copy import deepcopy +from ast import literal_eval +from tqdm.autonotebook import tqdm +from typing import Callable, Optional, Tuple +from multiprocessing import Pool + +from torchsig.datasets import conf +from torchsig.datasets.wideband import WidebandModulationsDataset +import torchsig.transforms as ST +from torchsig.utils import SignalData + + +def _identity(x): + return x + + +# Helper function for multiprocessing +def _get_data(idx, cfg): + np.random.seed(cfg.seed+idx*53) + wb_mds = WidebandModulationsDataset( + level=cfg.level, + num_iq_samples=cfg.num_iq_samples, + num_samples=1, # Dataset is randomly generated when indexed, so length here does not matter + target_transform=ST.DescToListTuple(), + seed=cfg.seed+idx*53, + use_gpu=cfg.use_gpu, + ) + return wb_mds[0] + + +class WidebandSig53: + """The Official WidebandSig53 dataset + + Args: + root (string): Root directory of dataset. A folder will be created for the requested version + of the dataset, an mdb file inside contains the data and labels. + train (bool, optional): If True, constructs the corresponding training set, + otherwise constructs the corresponding val set + impaired (bool, optional): If True, will construct the impaired version of the dataset, + with data passed through a seeded channel model + transform (callable, optional): A function/transform that takes in a complex64 ndarray + and returns a transformed version + target_transform (callable, optional): A function/transform that takes in the + target class (int) and returns a transformed version + regenerate (bool, optional): If True, data will be generated from scratch, otherwise the version + on disk will be used if it exists. + use_signal_data (bool, optional): If True, data and annotations will be setup as SignalData objects + gen_batch_size (int, optional): Batch size for parallelized data generation + + """ + modulation_list = [ + 'ook','bpsk','4pam','4ask','qpsk','8pam','8ask','8psk','16qam','16pam', + '16ask','16psk','32qam','32qam_cross','32pam','32ask','32psk','64qam', + '64pam','64ask','64psk','128qam_cross','256qam','512qam_cross', + '1024qam','2fsk','2gfsk','2msk','2gmsk','4fsk','4gfsk','4msk','4gmsk', + '8fsk','8gfsk','8msk','8gmsk','16fsk','16gfsk','16msk','16gmsk', + 'ofdm-64','ofdm-72','ofdm-128','ofdm-180','ofdm-256','ofdm-300', + 'ofdm-512','ofdm-600','ofdm-900','ofdm-1024','ofdm-1200','ofdm-2048', + ] + + def __init__( + self, + root: str, + train: bool = True, + impaired: bool = True, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + regenerate: bool = False, + use_signal_data: bool = True, + gen_batch_size: int = 1, + use_gpu: Optional[bool] = None, + ): + self.root = Path(root) + if not os.path.exists(self.root): + os.makedirs(self.root) + self.train = train + self.impaired = impaired + + self.T = transform if transform else _identity + self.TT = target_transform if target_transform else _identity + + cfg = ( + "WidebandSig53" + + ("Impaired" if impaired else "Clean") + + ("Train" if train else "Val") + + "Config" + ) + cfg = getattr(conf, cfg)() + cfg.use_gpu = use_gpu if use_gpu is not None else cfg.use_gpu + + self.use_signal_data = use_signal_data + self.signal_desc_transform = ST.ListTupleToDesc( + num_iq_samples=cfg.num_iq_samples, + class_list=self.modulation_list, + ) + + self.path = self.root / cfg.name + self.length = cfg.num_samples + regenerate = regenerate or not os.path.isdir(self.path) + + if regenerate and os.path.isdir(self.path): + shutil.rmtree(self.path) + + self._env = lmdb.open( + str(self.path).encode(), + max_dbs=2, + map_size=int(1e12), + max_readers=512, + readahead=False, + ) + + self._sample_db = self._env.open_db(b"iq_samples") + self._annotation_db = self._env.open_db(b"annotation") + + if regenerate: + if self.length % gen_batch_size != 0: + while self.length % gen_batch_size != 0: + gen_batch_size -= 1 + print("Rounding batch size down to {}".format(gen_batch_size)) + self.gen_batch_size = gen_batch_size + + print("Generating dataset...") + self._generate_data(cfg) + else: + print("Existing data found, skipping data generation") + + self._sample_txn = self._env.begin(db=self._sample_db) + self._annotation_txn = self._env.begin(db=self._annotation_db) + + def __len__(self) -> int: + return self.length + + def __getitem__(self, idx: int) -> Tuple[np.ndarray, int]: + idx = str(idx).encode() + x = pickle.loads(self._sample_txn.get(idx)) + y = literal_eval(self._annotation_txn.get(idx).decode('utf8')) + if self.use_signal_data: + data = SignalData( + data=deepcopy(x.tobytes()), + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex64), + signal_description=self.signal_desc_transform(y) + ) + data = self.T(data) + target = self.TT(data.signal_description) + data = data.iq_data + else: + data = self.T(x) + target = self.TT(y) + return data, target + + def _generate_data(self, cfg: conf.WidebandSig53Config) -> None: + state = np.random.get_state() + np.random.seed(cfg.seed) + + # Data retrieval batching for speed + batch_size = self.gen_batch_size + num_batches = int(self.length / batch_size) + + if batch_size == 1: + # Splitting case for single batch for tqdm progress bar over samples instead of batches + # Sequentially write retrieved data, annotations to LMDB + for i in tqdm(range(self.length)): + np.random.seed(cfg.seed+i*53) + wb_mds = WidebandModulationsDataset( + level=cfg.level, + num_iq_samples=cfg.num_iq_samples, + num_samples=1, # Dataset is randomly generated when indexed, so length here does not matter + target_transform=ST.DescToListTuple(), + seed=cfg.seed+i*53, + use_gpu=cfg.use_gpu, + ) + data, annotation = wb_mds[0] + data_c64 = data.astype(np.complex64) + with self._env.begin(write=True) as txn: + txn.put(str(i).encode(), pickle.dumps(data_c64), db=self._sample_db) + txn.put(str(i).encode(), str(annotation).encode(), db=self._annotation_db) + + else: + # Batched multiprocessing data, annotation retrieval + lmdb_idx = 0 + for batch_idx in tqdm(range(num_batches)): + process_index = [] + for batch_sample_idx in range(batch_size): + process_index.append((int(batch_idx*batch_size+batch_sample_idx), cfg)) + pool = Pool(batch_size) + result = pool.starmap(_get_data, process_index) + + # Sequentially write retrieved data, annotations to LMDB + for data, annotation in result: + data_c64 = data.astype(np.complex64) + with self._env.begin(write=True) as txn: + txn.put(str(lmdb_idx).encode(), pickle.dumps(data_c64), db=self._sample_db) + txn.put(str(lmdb_idx).encode(), str(annotation).encode(), db=self._annotation_db) + lmdb_idx += 1 + + np.random.set_state(state) + \ No newline at end of file diff --git a/torchsig/models/__init__.py b/torchsig/models/__init__.py index f671ecd..9f92126 100644 --- a/torchsig/models/__init__.py +++ b/torchsig/models/__init__.py @@ -1,2 +1,4 @@ -from .efficientnet import * -from .xcit import * \ No newline at end of file +from . import iq_models +from . import spectrogram_models +from torchsig.models.iq_models import * +from torchsig.models.spectrogram_models import * diff --git a/torchsig/models/iq_models/__init__.py b/torchsig/models/iq_models/__init__.py new file mode 100644 index 0000000..fed1a1f --- /dev/null +++ b/torchsig/models/iq_models/__init__.py @@ -0,0 +1,4 @@ +from .efficientnet import * +from .xcit import * +from torchsig.models.iq_models.efficientnet import * +from torchsig.models.iq_models.xcit import * diff --git a/torchsig/models/iq_models/efficientnet/LICENSE.md b/torchsig/models/iq_models/efficientnet/LICENSE.md new file mode 100644 index 0000000..b4e9438 --- /dev/null +++ b/torchsig/models/iq_models/efficientnet/LICENSE.md @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2019 Ross Wightman + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/torchsig/models/iq_models/efficientnet/README.md b/torchsig/models/iq_models/efficientnet/README.md new file mode 100644 index 0000000..dafc48c --- /dev/null +++ b/torchsig/models/iq_models/efficientnet/README.md @@ -0,0 +1,5 @@ +# EfficientNet + +The EfficientNet code contained here uses the PyTorch Image Models library, also known as [timm](https://github.com/rwightman/pytorch-image-models). + +timm is licensed under an Apache 2.0 license. This license for timm is contained within this directory. \ No newline at end of file diff --git a/torchsig/models/iq_models/efficientnet/__init__.py b/torchsig/models/iq_models/efficientnet/__init__.py new file mode 100644 index 0000000..7f2448f --- /dev/null +++ b/torchsig/models/iq_models/efficientnet/__init__.py @@ -0,0 +1 @@ +from .efficientnet import * \ No newline at end of file diff --git a/torchsig/models/efficientnet.py b/torchsig/models/iq_models/efficientnet/efficientnet.py similarity index 100% rename from torchsig/models/efficientnet.py rename to torchsig/models/iq_models/efficientnet/efficientnet.py diff --git a/torchsig/models/iq_models/xcit/LICENSE.md b/torchsig/models/iq_models/xcit/LICENSE.md new file mode 100644 index 0000000..b4e9438 --- /dev/null +++ b/torchsig/models/iq_models/xcit/LICENSE.md @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2019 Ross Wightman + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/torchsig/models/iq_models/xcit/README.md b/torchsig/models/iq_models/xcit/README.md new file mode 100644 index 0000000..f321b82 --- /dev/null +++ b/torchsig/models/iq_models/xcit/README.md @@ -0,0 +1,5 @@ +# XCiT + +The XCiT code contained here was developed with the official [XCiT GitHub](https://github.com/facebookresearch/xcit) used as reference, and it also uses the PyTorch Image Models library, also known as [timm](https://github.com/rwightman/pytorch-image-models). + +The official XCiT GitHub source code and timm are both licensed under an Apache 2.0 license. This license is contained within this directory. \ No newline at end of file diff --git a/torchsig/models/iq_models/xcit/__init__.py b/torchsig/models/iq_models/xcit/__init__.py new file mode 100644 index 0000000..da00170 --- /dev/null +++ b/torchsig/models/iq_models/xcit/__init__.py @@ -0,0 +1 @@ +from .xcit import * \ No newline at end of file diff --git a/torchsig/models/xcit.py b/torchsig/models/iq_models/xcit/xcit.py similarity index 100% rename from torchsig/models/xcit.py rename to torchsig/models/iq_models/xcit/xcit.py diff --git a/torchsig/models/spectrogram_models/__init__.py b/torchsig/models/spectrogram_models/__init__.py new file mode 100644 index 0000000..91b7b61 --- /dev/null +++ b/torchsig/models/spectrogram_models/__init__.py @@ -0,0 +1,8 @@ +from .yolov5 import * +from .detr import * +from .pspnet import * +from .mask2former import * +from torchsig.models.spectrogram_models.yolov5 import * +from torchsig.models.spectrogram_models.detr import * +from torchsig.models.spectrogram_models.pspnet import * +from torchsig.models.spectrogram_models.mask2former import * \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/detr/LICENSE.md b/torchsig/models/spectrogram_models/detr/LICENSE.md new file mode 100644 index 0000000..cc14143 --- /dev/null +++ b/torchsig/models/spectrogram_models/detr/LICENSE.md @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2020 - present, Facebook, Inc + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/detr/README.md b/torchsig/models/spectrogram_models/detr/README.md new file mode 100644 index 0000000..1b1c70b --- /dev/null +++ b/torchsig/models/spectrogram_models/detr/README.md @@ -0,0 +1,5 @@ +# DETR + +The DETR code contained here has been cloned, modified, and supplemented from its original [detr github](https://github.com/facebookresearch/detr). + +DETR is licensed under an Apache 2.0 license. This license for DETR is contained within this directory. diff --git a/torchsig/models/spectrogram_models/detr/__init__.py b/torchsig/models/spectrogram_models/detr/__init__.py new file mode 100644 index 0000000..bd38e28 --- /dev/null +++ b/torchsig/models/spectrogram_models/detr/__init__.py @@ -0,0 +1 @@ +from .detr import * \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/detr/detr.py b/torchsig/models/spectrogram_models/detr/detr.py new file mode 100644 index 0000000..f504170 --- /dev/null +++ b/torchsig/models/spectrogram_models/detr/detr.py @@ -0,0 +1,300 @@ +import timm +import gdown +import torch +import os.path +import numpy as np +from torch import nn + +from .modules import * +from .utils import * + + +__all__ = [ + "detr_b0_nano", "detr_b2_nano", "detr_b4_nano", + "detr_b0_nano_mod_family", "detr_b2_nano_mod_family", "detr_b4_nano_mod_family", +] + +model_urls = { + "detr_b0_nano": "1t6V3M5hJC8C-RSwPtgKGG89u5doibs46", + "detr_b2_nano": "1voDx7e0pBe_lGa_1sUYG8gyzOqz8nxmw", + "detr_b4_nano": "1RA7yGvpKiIXHXl_o89Zn6R2dVVTgKsWO", + "detr_b0_nano_mod_family": "1w42OxyAFf7CTJ5Yw8OU-kAZQZCpkNyaz", + "detr_b2_nano_mod_family": "1Wd8QD5Eq2mbEz3hkMlAQFxWZcxZChLma", + "detr_b4_nano_mod_family": "1ykrztgBc6c9knk1F2OirSUE_W3YbsTdB", +} + + +def detr_b0_nano( + pretrained: bool = False, + path: str = "detr_b0_nano.pt", + num_classes: int = 1, + drop_rate_backbone: float = 0.2, + drop_path_rate_backbone: float = 0.2, + drop_path_rate_transformer: float = 0.1, +): + """Constructs a DETR architecture with an EfficientNet-B0 backbone and an XCiT-Nano transformer. + DETR from `"End-to-End Object Detection with Transformers" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + XCiT from `"XCiT: Cross-Covariance Image Transformers" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + drop_path_rate_backbone (float): Backbone drop path rate for training + drop_rate_backbone (float): Backbone dropout rate for training + drop_path_rate_transformer (float): Transformer drop path rate for training + + """ + # Create DETR-B0-Nano + mdl = create_detr( + backbone='efficientnet_b0', + transformer='xcit-nano', + num_classes=1, + num_objects=50, + hidden_dim=256, + drop_rate_backbone=drop_rate_backbone, + drop_path_rate_backbone=drop_path_rate_backbone, + drop_path_rate_transformer=drop_path_rate_transformer, + ds_rate_transformer=2, + ds_method_transformer='chunker', + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['detr_b0_nano'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.linear_class = nn.Linear(mdl.linear_class.in_features, num_classes) + return mdl + + +def detr_b2_nano( + pretrained: bool = False, + path: str = "detr_b2_nano.pt", + num_classes: int = 1, + drop_rate_backbone: float = 0.3, + drop_path_rate_backbone: float = 0.2, + drop_path_rate_transformer: float = 0.1, +): + """Constructs a DETR architecture with an EfficientNet-B2 backbone and an XCiT-Nano transformer. + DETR from `"End-to-End Object Detection with Transformers" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + XCiT from `"XCiT: Cross-Covariance Image Transformers" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + drop_path_rate_backbone (float): Backbone drop path rate for training + drop_rate_backbone (float): Backbone dropout rate for training + drop_path_rate_transformer (float): Transformer drop path rate for training + + """ + # Create DETR-B2-Nano + mdl = create_detr( + backbone='efficientnet_b2', + transformer='xcit-nano', + num_classes=1, + num_objects=50, + hidden_dim=256, + drop_rate_backbone=drop_rate_backbone, + drop_path_rate_backbone=drop_path_rate_backbone, + drop_path_rate_transformer=drop_path_rate_transformer, + ds_rate_transformer=2, + ds_method_transformer='chunker', + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['detr_b2_nano'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.linear_class = nn.Linear(mdl.linear_class.in_features, num_classes) + return mdl + + +def detr_b4_nano( + pretrained: bool = False, + path: str = "detr_b4_nano.pt", + num_classes: int = 1, + drop_rate_backbone: float = 0.4, + drop_path_rate_backbone: float = 0.2, + drop_path_rate_transformer: float = 0.1, +): + """Constructs a DETR architecture with an EfficientNet-B4 backbone and an XCiT-Nano transformer. + DETR from `"End-to-End Object Detection with Transformers" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + XCiT from `"XCiT: Cross-Covariance Image Transformers" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + drop_path_rate_backbone (float): Backbone drop path rate for training + drop_rate_backbone (float): Backbone dropout rate for training + drop_path_rate_transformer (float): Transformer drop path rate for training + + """ + # Create DETR-B4-Nano + mdl = create_detr( + backbone='efficientnet_b4', + transformer='xcit-nano', + num_classes=1, + num_objects=50, + hidden_dim=256, + drop_rate_backbone=drop_rate_backbone, + drop_path_rate_backbone=drop_path_rate_backbone, + drop_path_rate_transformer=drop_path_rate_transformer, + ds_rate_transformer=2, + ds_method_transformer='chunker', + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['detr_b4_nano'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.linear_class = nn.Linear(mdl.linear_class.in_features, num_classes) + return mdl + + +def detr_b0_nano_mod_family( + pretrained: bool = False, + path: str = "detr_b0_nano_mod_family.pt", + num_classes: int = 6, + drop_rate_backbone: float = 0.2, + drop_path_rate_backbone: float = 0.2, + drop_path_rate_transformer: float = 0.1, +): + """Constructs a DETR architecture with an EfficientNet-B0 backbone and an XCiT-Nano transformer. + DETR from `"End-to-End Object Detection with Transformers" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + XCiT from `"XCiT: Cross-Covariance Image Transformers" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 6, final layer will not be loaded from checkpoint + drop_path_rate_backbone (float): Backbone drop path rate for training + drop_rate_backbone (float): Backbone dropout rate for training + drop_path_rate_transformer (float): Transformer drop path rate for training + + """ + # Create DETR-B0-Nano + mdl = create_detr( + backbone='efficientnet_b0', + transformer='xcit-nano', + num_classes=6, + num_objects=50, + hidden_dim=256, + drop_rate_backbone=drop_rate_backbone, + drop_path_rate_backbone=drop_path_rate_backbone, + drop_path_rate_transformer=drop_path_rate_transformer, + ds_rate_transformer=2, + ds_method_transformer='chunker', + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['detr_b0_nano_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.linear_class = nn.Linear(mdl.linear_class.in_features, num_classes) + return mdl + + +def detr_b2_nano_mod_family( + pretrained: bool = False, + path: str = "detr_b2_nano_mod_family.pt", + num_classes: int = 1, + drop_rate_backbone: float = 0.3, + drop_path_rate_backbone: float = 0.2, + drop_path_rate_transformer: float = 0.1, +): + """Constructs a DETR architecture with an EfficientNet-B2 backbone and an XCiT-Nano transformer. + DETR from `"End-to-End Object Detection with Transformers" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + XCiT from `"XCiT: Cross-Covariance Image Transformers" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 6, final layer will not be loaded from checkpoint + drop_path_rate_backbone (float): Backbone drop path rate for training + drop_rate_backbone (float): Backbone dropout rate for training + drop_path_rate_transformer (float): Transformer drop path rate for training + + """ + # Create DETR-B2-Nano + mdl = create_detr( + backbone='efficientnet_b2', + transformer='xcit-nano', + num_classes=6, + num_objects=50, + hidden_dim=256, + drop_rate_backbone=drop_rate_backbone, + drop_path_rate_backbone=drop_path_rate_backbone, + drop_path_rate_transformer=drop_path_rate_transformer, + ds_rate_transformer=2, + ds_method_transformer='chunker', + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['detr_b2_nano_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.linear_class = nn.Linear(mdl.linear_class.in_features, num_classes) + return mdl + + +def detr_b4_nano_mod_family( + pretrained: bool = False, + path: str = "detr_b4_nano_mod_family.pt", + num_classes: int = 6, + drop_rate_backbone: float = 0.4, + drop_path_rate_backbone: float = 0.2, + drop_path_rate_transformer: float = 0.1, +): + """Constructs a DETR architecture with an EfficientNet-B4 backbone and an XCiT-Nano transformer. + DETR from `"End-to-End Object Detection with Transformers" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + XCiT from `"XCiT: Cross-Covariance Image Transformers" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 6, final layer will not be loaded from checkpoint + drop_path_rate_backbone (float): Backbone drop path rate for training + drop_rate_backbone (float): Backbone dropout rate for training + drop_path_rate_transformer (float): Transformer drop path rate for training + + """ + # Create DETR-B4-Nano + mdl = create_detr( + backbone='efficientnet_b4', + transformer='xcit-nano', + num_classes=6, + num_objects=50, + hidden_dim=256, + drop_rate_backbone=drop_rate_backbone, + drop_path_rate_backbone=drop_path_rate_backbone, + drop_path_rate_transformer=drop_path_rate_transformer, + ds_rate_transformer=2, + ds_method_transformer='chunker', + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['detr_b0_nano_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.linear_class = nn.Linear(mdl.linear_class.in_features, num_classes) + return mdl diff --git a/torchsig/models/spectrogram_models/detr/modules.py b/torchsig/models/spectrogram_models/detr/modules.py new file mode 100644 index 0000000..211d103 --- /dev/null +++ b/torchsig/models/spectrogram_models/detr/modules.py @@ -0,0 +1,494 @@ +import timm +import torch +from torch import nn +from typing import List +from torch.nn import functional as F +from scipy.optimize import linear_sum_assignment + +from .utils import xcit_name_to_timm_name +from .utils import drop_classifier, find_output_features +from .utils import box_cxcywh_to_xyxy, generalized_box_iou +from .utils import is_dist_avail_and_initialized, get_world_size, accuracy + + +class ConvDownSampler(torch.nn.Module): + def __init__(self, in_chans, embed_dim, ds_rate=16): + super().__init__() + ds_rate //= 2 + chan = embed_dim // ds_rate + blocks = [ + torch.nn.Conv2d(in_chans, chan, (5,5), 2, 2), + torch.nn.BatchNorm2d(chan), + torch.nn.SiLU() + ] + + while ds_rate > 1: + blocks += [ + torch.nn.Conv2d(chan, 2 * chan, (5,5), 2, 2), + torch.nn.BatchNorm2d(2 * chan), + torch.nn.SiLU(), + ] + ds_rate //= 2 + chan = 2 * chan + + blocks += [ + torch.nn.Conv2d( + chan, + embed_dim, + (1,1), + ) + ] + self.blocks = torch.nn.Sequential(*blocks) + + def forward(self, X): + return self.blocks(X) + + +class Chunker(torch.nn.Module): + def __init__(self, in_chans, embed_dim, ds_rate=16): + super().__init__() + self.embed = torch.nn.Conv2d(in_chans, embed_dim // ds_rate, (7,7), padding=3) + self.project = torch.nn.Conv2d((embed_dim // ds_rate) * ds_rate, embed_dim, (1,1)) + self.ds_rate = ds_rate + + def forward(self, X): + X = self.embed(X) + X = torch.cat( + [ + torch.cat(torch.split(x_i, 1, -1), 1) + for x_i in torch.split(X, self.ds_rate, -1) + ], + -1, + ) + X = self.project(X) + + return X + + +class XCiT(torch.nn.Module): + def __init__(self, backbone, in_chans=2, num_objects=50, ds_rate=2, ds_method="downsample"): + super().__init__() + self.backbone = backbone + self.num_objects = num_objects + W = backbone.num_features + self.grouper = torch.nn.Conv1d(W, backbone.num_classes, 1) + if ds_method == "downsample": + self.backbone.patch_embed = ConvDownSampler(in_chans, W, ds_rate) + else: + self.backbone.patch_embed = Chunker(in_chans, W, ds_rate) + + def forward(self, x): + mdl = self.backbone + B = x.shape[0] + x = self.backbone.patch_embed(x) + + Hp, Wp = x.shape[-2], x.shape[-1] + pos_encoding = ( + mdl.pos_embed(B, Hp, Wp).reshape(B, -1, Hp*Wp).permute(0, 2, 1).half() + ) + x = x.reshape(B, -1, Hp*Wp).permute(0, 2,1) + pos_encoding + for blk in mdl.blocks: + x = blk(x, Hp, Wp) + cls_tokens = mdl.cls_token.expand(B, -1, -1) + x = torch.cat((cls_tokens, x), dim=1) + for blk in mdl.cls_attn_blocks: + x = blk(x) + x = mdl.norm(x) + x = self.grouper(x.transpose(1, 2)[:, :, :self.num_objects]) + x = x.squeeze() + if x.dim() == 2: + x = x.unsqueeze(0) + x = x.transpose(1,2) + return x + + +class MLP(torch.nn.Module): + """Very simple multi-layer perceptron (also called FFN) from DETR repo + + """ + def __init__(self, input_dim, hidden_dim, output_dim, num_layers): + super().__init__() + self.num_layers = num_layers + h = [hidden_dim] * (num_layers - 1) + self.layers = torch.nn.ModuleList( + torch.nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]) + ) + + def forward(self, x): + for i, layer in enumerate(self.layers): + x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x) + return x + + +class DETRModel(torch.nn.Module): + def __init__( + self, + backbone: torch.nn.Module, + transformer: torch.nn.Module, + num_classes: int = 53, + num_objects: int = 50, + hidden_dim: int = 256, + ): + super().__init__() + # Convolutional backbone + self.backbone = backbone + + # Conversion layer + self.conv = torch.nn.Conv2d( + in_channels=find_output_features(self.backbone), + out_channels=hidden_dim, + kernel_size=1, + ) + + # Transformer + self.transformer = transformer + + # Prediction heads, one extra class for predicting non-empty slots + self.linear_class = torch.nn.Linear(hidden_dim, num_classes + 1) + self.linear_bbox = MLP(hidden_dim, hidden_dim, 4, 3) + + def forward(self, x): + # Propagate inputs through backbone + x = self.backbone(x) + + # Convert from 2048 to 256 feature planes for the transformer + h = self.conv(x) + + # Propagate through the transformer + h = self.transformer(h) + + # Project transformer outputs to class labels and bounding boxes + return { + 'pred_logits': self.linear_class(h), + 'pred_boxes': self.linear_bbox(h).sigmoid() + } + + +class SetCriterion(nn.Module): + """ This class computes the loss for DETR. + The process happens in two steps: + 1) we compute hungarian assignment between ground truth boxes and the outputs of the model + 2) we supervise each pair of matched ground-truth / prediction (supervise class and box) + """ + def __init__( + self, + num_classes: int = 1, + class_loss_coef: float = 1.0, + bbox_loss_coef: float = 5.0, + giou_loss_coef: float = 2.0, + eos_coef: float = 0.1, + losses: List[str] = ['labels', 'boxes', 'cardinality'], + ): + """ Create the criterion. + Parameters: + num_classes: number of object categories, omitting the special no-object category + matcher: module able to compute a matching between targets and proposals + weight_dict: dict containing as key the names of the losses and as values their relative weight. + eos_coef: relative classification weight applied to the no-object category + losses: list of all the losses to be applied. See get_loss for list of available losses. + """ + super().__init__() + self.num_classes = num_classes + self.weight_dict = { + 'loss_ce': class_loss_coef, + 'loss_bbox': bbox_loss_coef, + 'loss_giou': giou_loss_coef, + } + self.matcher = HungarianMatcher( + cost_class=self.weight_dict['loss_ce'], + cost_bbox=self.weight_dict['loss_bbox'], + cost_giou=self.weight_dict['loss_giou'], + ) + self.eos_coef = eos_coef + self.losses = losses + empty_weight = torch.ones(self.num_classes + 1) + empty_weight[-1] = self.eos_coef + self.register_buffer('empty_weight', empty_weight) + + def loss_labels(self, outputs, targets, indices, num_boxes, log=True): + """Classification loss (NLL) + targets dicts must contain the key "labels" containing a tensor of dim [nb_target_boxes] + """ + assert 'pred_logits' in outputs + src_logits = outputs['pred_logits'] + + idx = self._get_src_permutation_idx(indices) + target_classes_o = torch.cat([t["labels"][J] for t, (_, J) in zip(targets, indices)]) + target_classes = torch.full( + src_logits.shape[:2], + self.num_classes, + dtype=torch.int64, + device=src_logits.device + ) + target_classes[idx] = target_classes_o + + loss_ce = F.cross_entropy(src_logits.transpose(1, 2), target_classes, self.empty_weight) + losses = {'loss_ce': loss_ce} + + if log: + # TODO this should probably be a separate loss, not hacked in this one here + losses['class_error'] = 100 - accuracy(src_logits[idx], target_classes_o)[0] + return losses + + @torch.no_grad() + def loss_cardinality(self, outputs, targets, indices, num_boxes): + """ Compute the cardinality error, ie the absolute error in the number of predicted non-empty boxes + This is not really a loss, it is intended for logging purposes only. It doesn't propagate gradients + """ + pred_logits = outputs['pred_logits'] + device = pred_logits.device + tgt_lengths = torch.as_tensor([len(v["labels"]) for v in targets], device=device) + # Count the number of predictions that are NOT "no-object" (which is the last class) + card_pred = (pred_logits.argmax(-1) != pred_logits.shape[-1] - 1).sum(1) + card_err = F.l1_loss(card_pred.float(), tgt_lengths.float()) + losses = {'cardinality_error': card_err} + return losses + + def loss_boxes(self, outputs, targets, indices, num_boxes): + """Compute the losses related to the bounding boxes, the L1 regression loss and the GIoU loss + targets dicts must contain the key "boxes" containing a tensor of dim [nb_target_boxes, 4] + The target boxes are expected in format (center_x, center_y, w, h), normalized by the image size. + """ + assert 'pred_boxes' in outputs + idx = self._get_src_permutation_idx(indices) + src_boxes = outputs['pred_boxes'][idx] + target_boxes = torch.cat([t['boxes'][i] for t, (_, i) in zip(targets, indices)], dim=0) + + loss_bbox = F.l1_loss(src_boxes, target_boxes, reduction='none') + + losses = {} + losses['loss_bbox'] = loss_bbox.sum() / num_boxes + + loss_giou = 1 - torch.diag(generalized_box_iou( + box_cxcywh_to_xyxy(src_boxes), + box_cxcywh_to_xyxy(target_boxes))) + losses['loss_giou'] = loss_giou.sum() / num_boxes + return losses + + def loss_masks(self, outputs, targets, indices, num_boxes): + """Compute the losses related to the masks: the focal loss and the dice loss. + targets dicts must contain the key "masks" containing a tensor of dim [nb_target_boxes, h, w] + """ + assert "pred_masks" in outputs + + src_idx = self._get_src_permutation_idx(indices) + tgt_idx = self._get_tgt_permutation_idx(indices) + src_masks = outputs["pred_masks"] + src_masks = src_masks[src_idx] + masks = [t["masks"] for t in targets] + # TODO use valid to mask invalid areas due to padding in loss + target_masks, valid = nested_tensor_from_tensor_list(masks).decompose() + target_masks = target_masks.to(src_masks) + target_masks = target_masks[tgt_idx] + + # upsample predictions to the target size + src_masks = interpolate(src_masks[:, None], size=target_masks.shape[-2:], + mode="bilinear", align_corners=False) + src_masks = src_masks[:, 0].flatten(1) + + target_masks = target_masks.flatten(1) + target_masks = target_masks.view(src_masks.shape) + losses = { + "loss_mask": sigmoid_focal_loss(src_masks, target_masks, num_boxes), + "loss_dice": dice_loss(src_masks, target_masks, num_boxes), + } + return losses + + def _get_src_permutation_idx(self, indices): + # permute predictions following indices + batch_idx = torch.cat([torch.full_like(src, i) for i, (src, _) in enumerate(indices)]) + src_idx = torch.cat([src for (src, _) in indices]) + return batch_idx, src_idx + + def _get_tgt_permutation_idx(self, indices): + # permute targets following indices + batch_idx = torch.cat([torch.full_like(tgt, i) for i, (_, tgt) in enumerate(indices)]) + tgt_idx = torch.cat([tgt for (_, tgt) in indices]) + return batch_idx, tgt_idx + + def get_loss(self, loss, outputs, targets, indices, num_boxes, **kwargs): + loss_map = { + 'labels': self.loss_labels, + 'cardinality': self.loss_cardinality, + 'boxes': self.loss_boxes, + 'masks': self.loss_masks + } + assert loss in loss_map, f'do you really want to compute {loss} loss?' + return loss_map[loss](outputs, targets, indices, num_boxes, **kwargs) + + def forward(self, outputs, targets): + """ This performs the loss computation. + Parameters: + outputs: dict of tensors, see the output specification of the model for the format + targets: list of dicts, such that len(targets) == batch_size. + The expected keys in each dict depends on the losses applied, see each loss' doc + """ + outputs_without_aux = {k: v for k, v in outputs.items() if k != 'aux_outputs'} + + # Retrieve the matching between the outputs of the last layer and the targets + indices = self.matcher(outputs_without_aux, targets) + + # Compute the average number of target boxes accross all nodes, for normalization purposes + num_boxes = sum(len(t["labels"]) for t in targets) + num_boxes = torch.as_tensor([num_boxes], dtype=torch.float, device=next(iter(outputs.values())).device) + if is_dist_avail_and_initialized(): + torch.distributed.all_reduce(num_boxes) + num_boxes = torch.clamp(num_boxes / get_world_size(), min=1).item() + + # Compute all the requested losses + losses = {} + for loss in self.losses: + losses.update(self.get_loss(loss, outputs, targets, indices, num_boxes)) + + # In case of auxiliary losses, we repeat this process with the output of each intermediate layer. + if 'aux_outputs' in outputs: + for i, aux_outputs in enumerate(outputs['aux_outputs']): + indices = self.matcher(aux_outputs, targets) + for loss in self.losses: + if loss == 'masks': + # Intermediate masks losses are too costly to compute, we ignore them. + continue + kwargs = {} + if loss == 'labels': + # Logging is enabled only for the last layer + kwargs = {'log': False} + l_dict = self.get_loss(loss, aux_outputs, targets, indices, num_boxes, **kwargs) + l_dict = {k + f'_{i}': v for k, v in l_dict.items()} + losses.update(l_dict) + + return losses + + +class HungarianMatcher(nn.Module): + """This class computes an assignment between the targets and the predictions of the network + For efficiency reasons, the targets don't include the no_object. Because of this, in general, + there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions, + while the others are un-matched (and thus treated as non-objects). + """ + def __init__(self, cost_class: float = 1, cost_bbox: float = 1, cost_giou: float = 1): + """Creates the matcher + Params: + cost_class: This is the relative weight of the classification error in the matching cost + cost_bbox: This is the relative weight of the L1 error of the bounding box coordinates in the matching cost + cost_giou: This is the relative weight of the giou loss of the bounding box in the matching cost + """ + super().__init__() + self.cost_class = cost_class + self.cost_bbox = cost_bbox + self.cost_giou = cost_giou + assert cost_class != 0 or cost_bbox != 0 or cost_giou != 0, "all costs cant be 0" + + @torch.no_grad() + def forward(self, outputs, targets): + """ Performs the matching + Params: + outputs: This is a dict that contains at least these entries: + "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits + "pred_boxes": Tensor of dim [batch_size, num_queries, 4] with the predicted box coordinates + targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing: + "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth + objects in the target) containing the class labels + "boxes": Tensor of dim [num_target_boxes, 4] containing the target box coordinates + Returns: + A list of size batch_size, containing tuples of (index_i, index_j) where: + - index_i is the indices of the selected predictions (in order) + - index_j is the indices of the corresponding selected targets (in order) + For each batch element, it holds: + len(index_i) = len(index_j) = min(num_queries, num_target_boxes) + """ + bs, num_queries = outputs["pred_logits"].shape[:2] + + # We flatten to compute the cost matrices in a batch + out_prob = outputs["pred_logits"].flatten(0, 1).softmax(-1) # [batch_size * num_queries, num_classes] + out_bbox = outputs["pred_boxes"].flatten(0, 1) # [batch_size * num_queries, 4] + + # Also concat the target labels and boxes + tgt_ids = torch.cat([v["labels"] for v in targets]) + tgt_bbox = torch.cat([v["boxes"] for v in targets]) + + # Compute the classification cost. Contrary to the loss, we don't use the NLL, + # but approximate it in 1 - proba[target class]. + # The 1 is a constant that doesn't change the matching, it can be ommitted. + cost_class = -out_prob[:, tgt_ids] + + # Compute the L1 cost between boxes + cost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1) + + # Compute the giou cost betwen boxes + cost_giou = -generalized_box_iou(box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox)) + + # Final cost matrix + C = self.cost_bbox * cost_bbox + self.cost_class * cost_class + self.cost_giou * cost_giou + C = C.view(bs, num_queries, -1).cpu() + + sizes = [len(v["boxes"]) for v in targets] + indices = [linear_sum_assignment(c[i]) for i, c in enumerate(C.split(sizes, -1))] + return [(torch.as_tensor(i, dtype=torch.int64), torch.as_tensor(j, dtype=torch.int64)) for i, j in indices] + + +def create_detr( + backbone: str = 'efficientnet_b0', + transformer: str = 'xcit-nano', + num_classes: int = 53, + num_objects: int = 50, + hidden_dim: int = 256, + drop_rate_backbone: float = 0.2, + drop_path_rate_backbone: float = 0.2, + drop_path_rate_transformer: float = 0.1, + ds_rate_transformer: int = 2, + ds_method_transformer: str = 'chunker', +) -> torch.nn.Module: + """ + Function used to build a DETR network + + Args: + TODO + + Returns: + torch.nn.Module + + """ + # build backbone + if 'eff' in backbone: + backbone = timm.create_model( + model_name=backbone, + in_chans=2, + drop_rate=drop_rate_backbone, + drop_path_rate=drop_path_rate_backbone, + ) + backbone = drop_classifier(backbone) + else: + raise NotImplemented('Only EfficientNet backbones are supported right now.') + + # Build transformer + if 'xcit' in transformer: + # map short name to timm name + model_name = xcit_name_to_timm_name(transformer) + + # build transformer + transformer = XCiT( + backbone=timm.create_model( + model_name=model_name, + drop_path_rate=drop_path_rate_transformer, + in_chans=hidden_dim, + num_classes=hidden_dim, + ), + in_chans=hidden_dim, + num_objects=num_objects, + ds_rate=ds_rate_transformer, + ds_method=ds_method_transformer, + ) + + else: + raise NotImplemented('Only XCiT transformers are supported right now.') + + # Build full DETR network + network = DETRModel( + backbone, + transformer, + num_classes=num_classes, + num_objects=num_objects, + hidden_dim=hidden_dim, + ) + + return network \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/detr/utils.py b/torchsig/models/spectrogram_models/detr/utils.py new file mode 100644 index 0000000..2f95d33 --- /dev/null +++ b/torchsig/models/spectrogram_models/detr/utils.py @@ -0,0 +1,195 @@ +import torch +import numpy as np +from torch import nn +import torch.distributed as dist +from typing import List, Optional +from torchvision.ops.boxes import box_area + + +def drop_classifier(parent): + return torch.nn.Sequential(*list(parent.children())[:-2]) + + +def find_output_features(parent, num_features=0): + for n, m in parent.named_children(): + if type(m) is torch.nn.Conv2d: + num_features = m.out_channels + else: + num_features = find_output_features(m, num_features) + return num_features + + +def xcit_name_to_timm_name(input_name: str) -> str: + if 'nano' in input_name: + model_name = 'xcit_nano_12_p16_224' + elif 'tiny' in input_name: + if '24' in input_name: + model_name = 'xcit_tiny_24_p16_224' + else: + model_name = 'xcit_tiny_12_p16_224' + elif 'small' in input_name: + model_name = 'xcit_small_24_p8_224' + elif 'medium' in input_name: + model_name = 'xcit_medium_24_p8_224' + elif 'large' in input_name: + model_name = 'xcit_large_24_p8_224' + else: + raise NotImplemented('Input transformer not supported.') + + return model_name + + +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + + +def get_world_size(): + if not is_dist_avail_and_initialized(): + return 1 + return dist.get_world_size() + + +@torch.no_grad() +def accuracy(output, target, topk=(1,)): + """Computes the precision@k for the specified values of k""" + if target.numel() == 0: + return [torch.zeros([], device=output.device)] + maxk = max(topk) + batch_size = target.size(0) + + _, pred = output.topk(maxk, 1, True, True) + pred = pred.t() + correct = pred.eq(target.view(1, -1).expand_as(pred)) + + res = [] + for k in topk: + correct_k = correct[:k].view(-1).float().sum(0) + res.append(correct_k.mul_(100.0 / batch_size)) + return res + + +def box_cxcywh_to_xyxy(x): + x_c, y_c, w, h = x.unbind(-1) + b = [(x_c - 0.5 * w), (y_c - 0.5 * h), + (x_c + 0.5 * w), (y_c + 0.5 * h)] + return torch.stack(b, dim=-1) + + +# modified from torchvision to also return the union +def box_iou(boxes1, boxes2): + area1 = box_area(boxes1) + area2 = box_area(boxes2) + + lt = torch.max(boxes1[:, None, :2], boxes2[:, :2]) # [N,M,2] + rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) # [N,M,2] + + wh = (rb - lt).clamp(min=0) # [N,M,2] + inter = wh[:, :, 0] * wh[:, :, 1] # [N,M] + + union = area1[:, None] + area2 - inter + + iou = inter / union + return iou, union + + +def generalized_box_iou(boxes1, boxes2): + """ + Generalized IoU from https://giou.stanford.edu/ + The boxes should be in [x0, y0, x1, y1] format + Returns a [N, M] pairwise matrix, where N = len(boxes1) + and M = len(boxes2) + """ + # degenerate boxes gives inf / nan results + # so do an early check + assert (boxes1[:, 2:] >= boxes1[:, :2]).all() + assert (boxes2[:, 2:] >= boxes2[:, :2]).all() + iou, union = box_iou(boxes1, boxes2) + + lt = torch.min(boxes1[:, None, :2], boxes2[:, :2]) + rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:]) + + wh = (rb - lt).clamp(min=0) # [N,M,2] + area = wh[:, :, 0] * wh[:, :, 1] + + return iou - (area - union) / area + + +def format_preds(preds): + map_preds = [] + for (i, (det_logits, det_boxes)) in enumerate(zip(preds['pred_logits'], preds['pred_boxes'])): + boxes = [] + scores = [] + labels = [] + + # Convert DETR output format to expected bboxes + num_objs = 0 + pred = {} + pred['pred_logits'] = det_logits + pred['pred_boxes'] = det_boxes + + det_list = [] + for obj_idx in range(pred['pred_logits'].shape[0]): + probs = pred['pred_logits'][obj_idx].softmax(-1) + max_prob = probs.max().cpu().detach().numpy() + max_class = probs.argmax().cpu().detach().numpy() + if max_class != (pred['pred_logits'].shape[1] - 1) and max_prob >= 0.5: + center_time = pred['pred_boxes'][obj_idx][0] + center_freq = pred['pred_boxes'][obj_idx][1] + duration = pred['pred_boxes'][obj_idx][2] + bandwidth = pred['pred_boxes'][obj_idx][3] + + # Save to box, score, label lists + x1 = max(0,(center_time - duration / 2) * 512) + y1 = max(0,(center_freq - bandwidth / 2) * 512) + x2 = min(512,(center_time + duration / 2) * 512) + y2 = min(512,(center_freq + bandwidth / 2) * 512) + + boxes.append([x1, y1, x2, y2]) + scores.extend([float(max_prob)]) + labels.extend([int(max_class)]) + + curr_pred = dict( + boxes=torch.tensor(boxes).to("cuda"), + scores=torch.tensor(scores).to("cuda"), + labels=torch.IntTensor(labels).to("cuda"), + ) + + map_preds.append(curr_pred) + + return map_preds + + +def format_targets(labels): + map_targets = [] + + for i, label in enumerate(labels): + boxes = [] + scores = [] + labels = [] + + for label_obj_idx in range(len(label['labels'])): + center_time = label["boxes"][label_obj_idx][0] + center_freq = label["boxes"][label_obj_idx][1] + duration = label["boxes"][label_obj_idx][2] + bandwidth = label["boxes"][label_obj_idx][3] + class_idx = label["labels"][label_obj_idx] + + x1 = (center_time - duration / 2) * 512 + y1 = (center_freq - bandwidth / 2) * 512 + x2 = (center_time + duration / 2) * 512 + y2 = (center_freq + bandwidth / 2) * 512 + + boxes.append([x1, y1, x2, y2]) + labels.extend([int(class_idx)]) + + curr_target = dict( + boxes=torch.tensor(boxes).to("cuda"), + labels=torch.IntTensor(labels).to("cuda"), + ) + map_targets.append(curr_target) + + return map_targets diff --git a/torchsig/models/spectrogram_models/mask2former/LICENSE_Detectron2.md b/torchsig/models/spectrogram_models/mask2former/LICENSE_Detectron2.md new file mode 100644 index 0000000..ea36abb --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/LICENSE_Detectron2.md @@ -0,0 +1,202 @@ +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, +and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by +the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all +other entities that control, are controlled by, or are under common +control with that entity. For the purposes of this definition, +"control" means (i) the power, direct or indirect, to cause the +direction or management of such entity, whether by contract or +otherwise, or (ii) ownership of fifty percent (50%) or more of the +outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity +exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, +including but not limited to software source code, documentation +source, and configuration files. + +"Object" form shall mean any form resulting from mechanical +transformation or translation of a Source form, including but +not limited to compiled object code, generated documentation, +and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or +Object form, made available under the License, as indicated by a +copyright notice that is included in or attached to the work +(an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object +form, that is based on (or derived from) the Work and for which the +editorial revisions, annotations, elaborations, or other modifications +represent, as a whole, an original work of authorship. For the purposes +of this License, Derivative Works shall not include works that remain +separable from, or merely link (or bind by name) to the interfaces of, +the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including +the original version of the Work and any modifications or additions +to that Work or Derivative Works thereof, that is intentionally +submitted to Licensor for inclusion in the Work by the copyright owner +or by an individual or Legal Entity authorized to submit on behalf of +the copyright owner. For the purposes of this definition, "submitted" +means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, +and issue tracking systems that are managed by, or on behalf of, the +Licensor for the purpose of discussing and improving the Work, but +excluding communication that is conspicuously marked or otherwise +designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity +on behalf of whom a Contribution has been received by Licensor and +subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of +this License, each Contributor hereby grants to You a perpetual, +worldwide, non-exclusive, no-charge, royalty-free, irrevocable +copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the +Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of +this License, each Contributor hereby grants to You a perpetual, +worldwide, non-exclusive, no-charge, royalty-free, irrevocable +(except as stated in this section) patent license to make, have made, +use, offer to sell, sell, import, and otherwise transfer the Work, +where such license applies only to those patent claims licensable +by such Contributor that are necessarily infringed by their +Contribution(s) alone or by combination of their Contribution(s) +with the Work to which such Contribution(s) was submitted. If You +institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work +or a Contribution incorporated within the Work constitutes direct +or contributory patent infringement, then any patent licenses +granted to You under this License for that Work shall terminate +as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the +Work or Derivative Works thereof in any medium, with or without +modifications, and in Source or Object form, provided that You +meet the following conditions: + +(a) You must give any other recipients of the Work or +Derivative Works a copy of this License; and + +(b) You must cause any modified files to carry prominent notices +stating that You changed the files; and + +(c) You must retain, in the Source form of any Derivative Works +that You distribute, all copyright, patent, trademark, and +attribution notices from the Source form of the Work, +excluding those notices that do not pertain to any part of +the Derivative Works; and + +(d) If the Work includes a "NOTICE" text file as part of its +distribution, then any Derivative Works that You distribute must +include a readable copy of the attribution notices contained +within such NOTICE file, excluding those notices that do not +pertain to any part of the Derivative Works, in at least one +of the following places: within a NOTICE text file distributed +as part of the Derivative Works; within the Source form or +documentation, if provided along with the Derivative Works; or, +within a display generated by the Derivative Works, if and +wherever such third-party notices normally appear. The contents +of the NOTICE file are for informational purposes only and +do not modify the License. You may add Your own attribution +notices within Derivative Works that You distribute, alongside +or as an addendum to the NOTICE text from the Work, provided +that such additional attribution notices cannot be construed +as modifying the License. + +You may add Your own copyright statement to Your modifications and +may provide additional or different license terms and conditions +for use, reproduction, or distribution of Your modifications, or +for any such Derivative Works as a whole, provided Your use, +reproduction, and distribution of the Work otherwise complies with +the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, +any Contribution intentionally submitted for inclusion in the Work +by You to the Licensor shall be under the terms and conditions of +this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify +the terms of any separate license agreement you may have executed +with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade +names, trademarks, service marks, or product names of the Licensor, +except as required for reasonable and customary use in describing the +origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or +agreed to in writing, Licensor provides the Work (and each +Contributor provides its Contributions) on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +implied, including, without limitation, any warranties or conditions +of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A +PARTICULAR PURPOSE. You are solely responsible for determining the +appropriateness of using or redistributing the Work and assume any +risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, +whether in tort (including negligence), contract, or otherwise, +unless required by applicable law (such as deliberate and grossly +negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, +incidental, or consequential damages of any character arising as a +result of this License or out of the use or inability to use the +Work (including but not limited to damages for loss of goodwill, +work stoppage, computer failure or malfunction, or any and all +other commercial damages or losses), even if such Contributor +has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing +the Work or Derivative Works thereof, You may choose to offer, +and charge a fee for, acceptance of support, warranty, indemnity, +or other liability obligations and/or rights consistent with this +License. However, in accepting such obligations, You may act only +on Your own behalf and on Your sole responsibility, not on behalf +of any other Contributor, and only if You agree to indemnify, +defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason +of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + +To apply the Apache License to your work, attach the following +boilerplate notice, with the fields enclosed by brackets "[]" +replaced with your own identifying information. (Don't include +the brackets!) The text should be enclosed in the appropriate +comment syntax for the file format. We also recommend that a +file or class name and description of purpose be included on the +same "printed page" as the copyright notice for easier +identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/mask2former/LICENSE_Mask2Former.md b/torchsig/models/spectrogram_models/mask2former/LICENSE_Mask2Former.md new file mode 100644 index 0000000..40b7f64 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/LICENSE_Mask2Former.md @@ -0,0 +1,19 @@ +Copyright (c) 2022 Meta, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/mask2former/README.md b/torchsig/models/spectrogram_models/mask2former/README.md new file mode 100644 index 0000000..2798cf6 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/README.md @@ -0,0 +1,5 @@ +# Mask2Former + +The Mask2Former code contained here is a cloned, modified, and supplemented version from the original source provided by the authors at the official [Mask2Former GitHub](https://github.com/facebookresearch/Mask2Former) site. Additionally, since Mask2Former's source code was built using the [Detectron2](https://github.com/facebookresearch/detectron2) framework, several features of Detectron2 have been pulled into these modules. + +The original Mask2Former code is licensed under an MIT license. The original Detectron2 code is licensed under an Apache 2.0 license. These licenses are contained within this directory. diff --git a/torchsig/models/spectrogram_models/mask2former/__init__.py b/torchsig/models/spectrogram_models/mask2former/__init__.py new file mode 100644 index 0000000..2caec72 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/__init__.py @@ -0,0 +1 @@ +from .mask2former import * \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/mask2former/backbone.py b/torchsig/models/spectrogram_models/mask2former/backbone.py new file mode 100644 index 0000000..c93ffee --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/backbone.py @@ -0,0 +1,38 @@ +import timm +import numpy as np +import torch +import torch.nn as nn + + +class ResNet50Backbone(nn.Module): + def __init__(self): + super().__init__() + self.resnet50 = timm.create_model('resnet50', in_chans=2).float() + + def forward(self, x): + features = {} + layers = list(self.resnet50.children()) + for i, layer in enumerate(layers): + x = layer(x) + if isinstance(layer, nn.Sequential): + features[str(len(features))] = x + return features + + +class EffNetBackbone(nn.Module): + def __init__(self, network='efficientnet_b0'): + super().__init__() + self.network = timm.create_model(network, in_chans=2).float() + + def forward(self, x): + features = {} + layers = list(self.network.children()) + for i, layer in enumerate(layers): + if isinstance(layer, nn.Sequential): + for ii, blocks in enumerate(layer): + x = blocks(x) + if isinstance(blocks, nn.Sequential): + features[str(len(features))] = x + else: + x = layer(x) + return features \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/mask2former/criterion.py b/torchsig/models/spectrogram_models/mask2former/criterion.py new file mode 100644 index 0000000..2d57228 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/criterion.py @@ -0,0 +1,583 @@ +""" +Criterion and matching modules from Detectron2, Mask2Former, and DETR codebases +""" +import numpy as np +import torch +from torch import nn, Tensor +import torch.nn.functional as F +import torch.distributed as dist +from torch.cuda.amp import autocast +import torchvision +from scipy.optimize import linear_sum_assignment +from typing import List, Optional + +from .utils import _max_by_axis + + +def get_world_size() -> int: + if not dist.is_available(): + return 1 + if not dist.is_initialized(): + return 1 + return dist.get_world_size() + + +def get_uncertain_point_coords_with_randomness( + coarse_logits, uncertainty_func, num_points, oversample_ratio, importance_sample_ratio +): + """ + Sample points in [0, 1] x [0, 1] coordinate space based on their uncertainty. The unceratinties + are calculated for each point using 'uncertainty_func' function that takes point's logit + prediction as input. + See PointRend paper for details. + Args: + coarse_logits (Tensor): A tensor of shape (N, C, Hmask, Wmask) or (N, 1, Hmask, Wmask) for + class-specific or class-agnostic prediction. + uncertainty_func: A function that takes a Tensor of shape (N, C, P) or (N, 1, P) that + contains logit predictions for P points and returns their uncertainties as a Tensor of + shape (N, 1, P). + num_points (int): The number of points P to sample. + oversample_ratio (int): Oversampling parameter. + importance_sample_ratio (float): Ratio of points that are sampled via importnace sampling. + Returns: + point_coords (Tensor): A tensor of shape (N, P, 2) that contains the coordinates of P + sampled points. + """ + assert oversample_ratio >= 1 + assert importance_sample_ratio <= 1 and importance_sample_ratio >= 0 + num_boxes = coarse_logits.shape[0] + num_sampled = int(num_points * oversample_ratio) + point_coords = torch.rand(num_boxes, num_sampled, 2, device=coarse_logits.device) + point_logits = point_sample(coarse_logits, point_coords, align_corners=False) + # It is crucial to calculate uncertainty based on the sampled prediction value for the points. + # Calculating uncertainties of the coarse predictions first and sampling them for points leads + # to incorrect results. + # To illustrate this: assume uncertainty_func(logits)=-abs(logits), a sampled point between + # two coarse predictions with -1 and 1 logits has 0 logits, and therefore 0 uncertainty value. + # However, if we calculate uncertainties for the coarse predictions first, + # both will have -1 uncertainty, and the sampled point will get -1 uncertainty. + point_uncertainties = uncertainty_func(point_logits) + num_uncertain_points = int(importance_sample_ratio * num_points) + num_random_points = num_points - num_uncertain_points + idx = torch.topk(point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1] + shift = num_sampled * torch.arange(num_boxes, dtype=torch.long, device=coarse_logits.device) + idx += shift[:, None] + point_coords = point_coords.view(-1, 2)[idx.view(-1), :].view( + num_boxes, num_uncertain_points, 2 + ) + if num_random_points > 0: + point_coords = torch.cat( + [ + point_coords, + torch.rand(num_boxes, num_random_points, 2, device=coarse_logits.device), + ], + dim=1, + ) + return point_coords + + +def point_sample(input, point_coords, **kwargs): + """ + A wrapper around :function:`torch.nn.functional.grid_sample` to support 3D point_coords tensors. + Unlike :function:`torch.nn.functional.grid_sample` it assumes `point_coords` to lie inside + [0, 1] x [0, 1] square. + Args: + input (Tensor): A tensor of shape (N, C, H, W) that contains features map on a H x W grid. + point_coords (Tensor): A tensor of shape (N, P, 2) or (N, Hgrid, Wgrid, 2) that contains + [0, 1] x [0, 1] normalized point coordinates. + Returns: + output (Tensor): A tensor of shape (N, C, P) or (N, C, Hgrid, Wgrid) that contains + features for points in `point_coords`. The features are obtained via bilinear + interplation from `input` the same way as :function:`torch.nn.functional.grid_sample`. + """ + add_dim = False + if point_coords.dim() == 3: + add_dim = True + point_coords = point_coords.unsqueeze(2) + output = F.grid_sample(input, 2.0 * point_coords - 1.0, **kwargs) + if add_dim: + output = output.squeeze(3) + return output + + +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + + +def nested_tensor_from_tensor_list(tensor_list: List[Tensor]): + # TODO make this more general + if tensor_list[0].ndim == 3: + if torchvision._is_tracing(): + # nested_tensor_from_tensor_list() does not export well to ONNX + # call _onnx_nested_tensor_from_tensor_list() instead + return _onnx_nested_tensor_from_tensor_list(tensor_list) + + # TODO make it support different-sized images + max_size = _max_by_axis([list(img.shape) for img in tensor_list]) + # min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list])) + batch_shape = [len(tensor_list)] + max_size + b, c, h, w = batch_shape + dtype = tensor_list[0].dtype + device = tensor_list[0].device + tensor = torch.zeros(batch_shape, dtype=dtype, device=device) + mask = torch.ones((b, h, w), dtype=torch.bool, device=device) + for img, pad_img, m in zip(tensor_list, tensor, mask): + pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img) + m[: img.shape[1], : img.shape[2]] = False + else: + raise ValueError("not supported") + return NestedTensor(tensor, mask) + + +class NestedTensor(object): + def __init__(self, tensors, mask: Optional[Tensor]): + self.tensors = tensors + self.mask = mask + + def to(self, device): + # type: (Device) -> NestedTensor # noqa + cast_tensor = self.tensors.to(device) + mask = self.mask + if mask is not None: + assert mask is not None + cast_mask = mask.to(device) + else: + cast_mask = None + return NestedTensor(cast_tensor, cast_mask) + + def decompose(self): + return self.tensors, self.mask + + def __repr__(self): + return str(self.tensors) + + +def dice_loss( + inputs: torch.Tensor, + targets: torch.Tensor, + num_masks: float, + ): + """ + Compute the DICE loss, similar to generalized IOU for masks + Args: + inputs: A float tensor of arbitrary shape. + The predictions for each example. + targets: A float tensor with the same shape as inputs. Stores the binary + classification label for each element in inputs + (0 for the negative class and 1 for the positive class). + """ + inputs = inputs.sigmoid() + inputs = inputs.flatten(1) + numerator = 2 * (inputs * targets).sum(-1) + denominator = inputs.sum(-1) + targets.sum(-1) + loss = 1 - (numerator + 1) / (denominator + 1) + return loss.sum() / num_masks + + +dice_loss_jit = torch.jit.script( + dice_loss +) # type: torch.jit.ScriptModule + + +def sigmoid_ce_loss( + inputs: torch.Tensor, + targets: torch.Tensor, + num_masks: float, + ): + """ + Args: + inputs: A float tensor of arbitrary shape. + The predictions for each example. + targets: A float tensor with the same shape as inputs. Stores the binary + classification label for each element in inputs + (0 for the negative class and 1 for the positive class). + Returns: + Loss tensor + """ + loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction="none") + + return loss.mean(1).sum() / num_masks + + +sigmoid_ce_loss_jit = torch.jit.script( + sigmoid_ce_loss +) # type: torch.jit.ScriptModule + + +def calculate_uncertainty(logits): + """ + We estimate uncerainty as L1 distance between 0.0 and the logit prediction in 'logits' for the + foreground class in `classes`. + Args: + logits (Tensor): A tensor of shape (R, 1, ...) for class-specific or + class-agnostic, where R is the total number of predicted masks in all images and C is + the number of foreground classes. The values are logits. + Returns: + scores (Tensor): A tensor of shape (R, 1, ...) that contains uncertainty scores with + the most uncertain locations having the highest uncertainty score. + """ + assert logits.shape[1] == 1 + gt_class_logits = logits.clone() + return -(torch.abs(gt_class_logits)) + + +class SetCriterion(nn.Module): + """This class computes the loss for DETR. + The process happens in two steps: + 1) we compute hungarian assignment between ground truth boxes and the outputs of the model + 2) we supervise each pair of matched ground-truth / prediction (supervise class and box) + """ + + def __init__(self, num_classes, matcher, weight_dict, eos_coef, losses, + num_points, oversample_ratio, importance_sample_ratio): + """Create the criterion. + Parameters: + num_classes: number of object categories, omitting the special no-object category + matcher: module able to compute a matching between targets and proposals + weight_dict: dict containing as key the names of the losses and as values their relative weight. + eos_coef: relative classification weight applied to the no-object category + losses: list of all the losses to be applied. See get_loss for list of available losses. + """ + super().__init__() + self.num_classes = num_classes + self.matcher = matcher + self.weight_dict = weight_dict + self.eos_coef = eos_coef + self.losses = losses + empty_weight = torch.ones(self.num_classes + 1) + empty_weight[-1] = self.eos_coef + self.register_buffer("empty_weight", empty_weight) + + # pointwise mask loss parameters + self.num_points = num_points + self.oversample_ratio = oversample_ratio + self.importance_sample_ratio = importance_sample_ratio + + def loss_labels(self, outputs, targets, indices, num_masks): + """Classification loss (NLL) + targets dicts must contain the key "labels" containing a tensor of dim [nb_target_boxes] + """ + assert "pred_logits" in outputs + src_logits = outputs["pred_logits"].float() + + idx = self._get_src_permutation_idx(indices) + target_classes_o = torch.cat([t["labels"][J] for t, (_, J) in zip(targets, indices)]) + target_classes = torch.full( + src_logits.shape[:2], self.num_classes, dtype=torch.int64, device=src_logits.device + ) + target_classes[idx] = target_classes_o + + loss_ce = F.cross_entropy(src_logits.transpose(1, 2), target_classes, self.empty_weight) + losses = {"loss_ce": loss_ce} + return losses + + def loss_masks(self, outputs, targets, indices, num_masks): + """Compute the losses related to the masks: the focal loss and the dice loss. + targets dicts must contain the key "masks" containing a tensor of dim [nb_target_boxes, h, w] + """ + assert "pred_masks" in outputs + + src_idx = self._get_src_permutation_idx(indices) + tgt_idx = self._get_tgt_permutation_idx(indices) + src_masks = outputs["pred_masks"] + src_masks = src_masks[src_idx] + masks = [t["masks"] for t in targets] + # TODO use valid to mask invalid areas due to padding in loss + target_masks, valid = nested_tensor_from_tensor_list(masks).decompose() + target_masks = target_masks.to(src_masks) + target_masks = target_masks[tgt_idx] + + # No need to upsample predictions as we are using normalized coordinates :) + # N x 1 x H x W + src_masks = src_masks[:, None] + target_masks = target_masks[:, None] + + with torch.no_grad(): + # sample point_coords + point_coords = get_uncertain_point_coords_with_randomness( + src_masks, + lambda logits: calculate_uncertainty(logits), + self.num_points, + self.oversample_ratio, + self.importance_sample_ratio, + ) + # get gt labels + point_labels = point_sample( + target_masks, + point_coords, + align_corners=False, + ).squeeze(1) + + point_logits = point_sample( + src_masks, + point_coords, + align_corners=False, + ).squeeze(1) + + losses = { + "loss_mask": sigmoid_ce_loss_jit(point_logits, point_labels, num_masks), + "loss_dice": dice_loss_jit(point_logits, point_labels, num_masks), + } + + del src_masks + del target_masks + return losses + + def _get_src_permutation_idx(self, indices): + # permute predictions following indices + batch_idx = torch.cat([torch.full_like(src, i) for i, (src, _) in enumerate(indices)]) + src_idx = torch.cat([src for (src, _) in indices]) + return batch_idx, src_idx + + def _get_tgt_permutation_idx(self, indices): + # permute targets following indices + batch_idx = torch.cat([torch.full_like(tgt, i) for i, (_, tgt) in enumerate(indices)]) + tgt_idx = torch.cat([tgt for (_, tgt) in indices]) + return batch_idx, tgt_idx + + def get_loss(self, loss, outputs, targets, indices, num_masks): + loss_map = { + 'labels': self.loss_labels, + 'masks': self.loss_masks, + } + assert loss in loss_map, f"do you really want to compute {loss} loss?" + return loss_map[loss](outputs, targets, indices, num_masks) + + def forward(self, outputs, targets): + """This performs the loss computation. + Parameters: + outputs: dict of tensors, see the output specification of the model for the format + targets: list of dicts, such that len(targets) == batch_size. + The expected keys in each dict depends on the losses applied, see each loss' doc + """ + outputs_without_aux = {k: v for k, v in outputs.items() if k != "aux_outputs"} + + # Retrieve the matching between the outputs of the last layer and the targets + indices = self.matcher(outputs_without_aux, targets) + + # Compute the average number of target boxes accross all nodes, for normalization purposes + num_masks = sum(len(t["labels"]) for t in targets) + num_masks = torch.as_tensor( + [num_masks], dtype=torch.float, device=next(iter(outputs.values())).device + ) + if is_dist_avail_and_initialized(): + torch.distributed.all_reduce(num_masks) + num_masks = torch.clamp(num_masks / get_world_size(), min=1).item() + + # Compute all the requested losses + losses = {} + for loss in self.losses: + losses.update(self.get_loss(loss, outputs, targets, indices, num_masks)) + + # In case of auxiliary losses, we repeat this process with the output of each intermediate layer. + if "aux_outputs" in outputs: + for i, aux_outputs in enumerate(outputs["aux_outputs"]): + indices = self.matcher(aux_outputs, targets) + for loss in self.losses: + l_dict = self.get_loss(loss, aux_outputs, targets, indices, num_masks) + l_dict = {k + f"_{i}": v for k, v in l_dict.items()} + losses.update(l_dict) + + return losses + + def __repr__(self): + head = "Criterion " + self.__class__.__name__ + body = [ + "matcher: {}".format(self.matcher.__repr__(_repr_indent=8)), + "losses: {}".format(self.losses), + "weight_dict: {}".format(self.weight_dict), + "num_classes: {}".format(self.num_classes), + "eos_coef: {}".format(self.eos_coef), + "num_points: {}".format(self.num_points), + "oversample_ratio: {}".format(self.oversample_ratio), + "importance_sample_ratio: {}".format(self.importance_sample_ratio), + ] + _repr_indent = 4 + lines = [head] + [" " * _repr_indent + line for line in body] + return "\n".join(lines) + + +def batch_dice_loss(inputs: torch.Tensor, targets: torch.Tensor): + """ + Compute the DICE loss, similar to generalized IOU for masks + Args: + inputs: A float tensor of arbitrary shape. + The predictions for each example. + targets: A float tensor with the same shape as inputs. Stores the binary + classification label for each element in inputs + (0 for the negative class and 1 for the positive class). + """ + inputs = inputs.sigmoid() + inputs = inputs.flatten(1) + numerator = 2 * torch.einsum("nc,mc->nm", inputs, targets) + denominator = inputs.sum(-1)[:, None] + targets.sum(-1)[None, :] + loss = 1 - (numerator + 1) / (denominator + 1) + return loss + + +batch_dice_loss_jit = torch.jit.script( + batch_dice_loss +) # type: torch.jit.ScriptModule + + +def batch_sigmoid_ce_loss(inputs: torch.Tensor, targets: torch.Tensor): + """ + Args: + inputs: A float tensor of arbitrary shape. + The predictions for each example. + targets: A float tensor with the same shape as inputs. Stores the binary + classification label for each element in inputs + (0 for the negative class and 1 for the positive class). + Returns: + Loss tensor + """ + hw = inputs.shape[1] + + pos = F.binary_cross_entropy_with_logits( + inputs, torch.ones_like(inputs), reduction="none" + ) + neg = F.binary_cross_entropy_with_logits( + inputs, torch.zeros_like(inputs), reduction="none" + ) + + loss = torch.einsum("nc,mc->nm", pos, targets) + torch.einsum( + "nc,mc->nm", neg, (1 - targets) + ) + + return loss / hw + + +batch_sigmoid_ce_loss_jit = torch.jit.script( + batch_sigmoid_ce_loss +) # type: torch.jit.ScriptModule + + +class HungarianMatcher(nn.Module): + """This class computes an assignment between the targets and the predictions of the network + + For efficiency reasons, the targets don't include the no_object. Because of this, in general, + there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions, + while the others are un-matched (and thus treated as non-objects). + """ + + def __init__(self, cost_class: float = 1, cost_mask: float = 1, cost_dice: float = 1, num_points: int = 0): + """Creates the matcher + + Params: + cost_class: This is the relative weight of the classification error in the matching cost + cost_mask: This is the relative weight of the focal loss of the binary mask in the matching cost + cost_dice: This is the relative weight of the dice loss of the binary mask in the matching cost + """ + super().__init__() + self.cost_class = cost_class + self.cost_mask = cost_mask + self.cost_dice = cost_dice + + assert cost_class != 0 or cost_mask != 0 or cost_dice != 0, "all costs cant be 0" + + self.num_points = num_points + + @torch.no_grad() + def memory_efficient_forward(self, outputs, targets): + """More memory-friendly matching""" + bs, num_queries = outputs["pred_logits"].shape[:2] + + indices = [] + + # Iterate through batch size + for b in range(bs): + + out_prob = outputs["pred_logits"][b].softmax(-1) # [num_queries, num_classes] + tgt_ids = targets[b]["labels"] + + # Compute the classification cost. Contrary to the loss, we don't use the NLL, + # but approximate it in 1 - proba[target class]. + # The 1 is a constant that doesn't change the matching, it can be ommitted. + cost_class = -out_prob[:, tgt_ids] + + out_mask = outputs["pred_masks"][b] # [num_queries, H_pred, W_pred] + # gt masks are already padded when preparing target + tgt_mask = targets[b]["masks"].to(out_mask) + + out_mask = out_mask[:, None] + tgt_mask = tgt_mask[:, None] + # all masks share the same set of points for efficient matching! + point_coords = torch.rand(1, self.num_points, 2, device=out_mask.device) + # get gt labels + tgt_mask = point_sample( + tgt_mask, + point_coords.repeat(tgt_mask.shape[0], 1, 1), + align_corners=False, + ).squeeze(1) + + out_mask = point_sample( + out_mask, + point_coords.repeat(out_mask.shape[0], 1, 1), + align_corners=False, + ).squeeze(1) + + with autocast(enabled=False): + out_mask = out_mask.float() + tgt_mask = tgt_mask.float() + # Compute the focal loss between masks + cost_mask = batch_sigmoid_ce_loss_jit(out_mask, tgt_mask) + + # Compute the dice loss betwen masks + with torch.jit.optimized_execution(False): + cost_dice = batch_dice_loss_jit(out_mask, tgt_mask) + + # Final cost matrix + C = ( + self.cost_mask * cost_mask + + self.cost_class * cost_class + + self.cost_dice * cost_dice + ) + C = C.reshape(num_queries, -1).cpu() + + # -inf values cause error in linear_sum_assignment so replace with large neg + if -np.inf in C: + C = C[np.where(C==-np.inf)] = -1e9 + + indices.append(linear_sum_assignment(C)) + + return [ + (torch.as_tensor(i, dtype=torch.int64), torch.as_tensor(j, dtype=torch.int64)) + for i, j in indices + ] + + @torch.no_grad() + def forward(self, outputs, targets): + """Performs the matching + + Params: + outputs: This is a dict that contains at least these entries: + "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits + "pred_masks": Tensor of dim [batch_size, num_queries, H_pred, W_pred] with the predicted masks + + targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing: + "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth + objects in the target) containing the class labels + "masks": Tensor of dim [num_target_boxes, H_gt, W_gt] containing the target masks + + Returns: + A list of size batch_size, containing tuples of (index_i, index_j) where: + - index_i is the indices of the selected predictions (in order) + - index_j is the indices of the corresponding selected targets (in order) + For each batch element, it holds: + len(index_i) = len(index_j) = min(num_queries, num_target_boxes) + """ + return self.memory_efficient_forward(outputs, targets) + + def __repr__(self, _repr_indent=4): + head = "Matcher " + self.__class__.__name__ + body = [ + "cost_class: {}".format(self.cost_class), + "cost_mask: {}".format(self.cost_mask), + "cost_dice: {}".format(self.cost_dice), + ] + lines = [head] + [" " * _repr_indent + line for line in body] + return "\n".join(lines) diff --git a/torchsig/models/spectrogram_models/mask2former/mask2former.py b/torchsig/models/spectrogram_models/mask2former/mask2former.py new file mode 100644 index 0000000..2cba851 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/mask2former.py @@ -0,0 +1,258 @@ +import timm +import gdown +import torch +import os.path +import numpy as np +from torch import nn + +from .utils import non_max_suppression_df, format_preds, format_targets +from .criterion import SetCriterion, HungarianMatcher + + +__all__ = [ + "mask2former_b0", "mask2former_b2", "mask2former_b4", + "mask2former_b0_mod_family", "mask2former_b2_mod_family", "mask2former_b4_mod_family", +] + +model_urls = { + "mask2former_b0": "1sioOi9k1O3tzxM1Hu5CpME1u9Q3wt_ht", + "mask2former_b2": "1ZJOSu5jLUS-ZgUmytXdMcyuwHaw5C10b", + "mask2former_b4": "1xBdw6oGLn7M3JUR7D7p1mbwelcWUsAvj", + "mask2former_b0_mod_family": "1eRijUw6zuMvPIHNB4-9NwN3rY_1fFA7i", + "mask2former_b2_mod_family": "1pKAGMALwc3XBg1l14cYDHNFw2ObtHMnx", + "mask2former_b4_mod_family": "1-_86eGkTDaq9uykgTEZOo1Gky5ITXLJI", +} + + +def mask2former_b0( + pretrained: bool = False, + path: str = "mask2former_b0.pt", + num_classes: int = 1, +): + """Constructs a Mask2Former architecture with an EfficientNet-B0 backbone. + Mask2Former from `"Masked-attention Mask Transformer for Universal Image Segmentation" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + + """ + from .modules import Mask2FormerModel, create_mask2former + + # Create Mask2Former-B0 + mdl = create_mask2former( + backbone='efficientnet_b0', + pixel_decoder='multi_scale_deformable_attention', + predictor='multi_scale_masked_transformer_decoder', + num_classes=1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['mask2former_b0'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + raise NotImplemented('Mask2Former implementation does not support finetuning to different class sizes yet.') + return mdl + + +def mask2former_b2( + pretrained: bool = False, + path: str = "mask2former_b2.pt", + num_classes: int = 1, +): + """Constructs a Mask2Former architecture with an EfficientNet-B2 backbone. + Mask2Former from `"Masked-attention Mask Transformer for Universal Image Segmentation" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + + """ + from .modules import Mask2FormerModel, create_mask2former + + # Create Mask2Former-B2 + mdl = create_mask2former( + backbone='efficientnet_b2', + pixel_decoder='multi_scale_deformable_attention', + predictor='multi_scale_masked_transformer_decoder', + num_classes=1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['mask2former_b2'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + raise NotImplemented('Mask2Former implementation does not support finetuning to different class sizes yet.') + return mdl + + +def mask2former_b4( + pretrained: bool = False, + path: str = "mask2former_b4.pt", + num_classes: int = 1, +): + """Constructs a Mask2Former architecture with an EfficientNet-B4 backbone. + Mask2Former from `"Masked-attention Mask Transformer for Universal Image Segmentation" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + + """ + from .modules import Mask2FormerModel, create_mask2former + + # Create Mask2Former-B4 + mdl = create_mask2former( + backbone='efficientnet_b4', + pixel_decoder='multi_scale_deformable_attention', + predictor='multi_scale_masked_transformer_decoder', + num_classes=1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['mask2former_b4'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + raise NotImplemented('Mask2Former implementation does not support finetuning to different class sizes yet.') + return mdl + + +def mask2former_b0_mod_family( + pretrained: bool = False, + path: str = "mask2former_b0_mod_family.pt", + num_classes: int = 6, +): + """Constructs a Mask2Former architecture with an EfficientNet-B0 backbone. + Mask2Former from `"Masked-attention Mask Transformer for Universal Image Segmentation" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 6, final layer will not be loaded from checkpoint + + """ + from .modules import Mask2FormerModel, create_mask2former + + # Create Mask2Former-B0 + mdl = create_mask2former( + backbone='efficientnet_b0', + pixel_decoder='multi_scale_deformable_attention', + predictor='multi_scale_masked_transformer_decoder', + num_classes=6, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['mask2former_b0_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + raise NotImplemented('Mask2Former implementation does not support finetuning to different class sizes yet.') + return mdl + + +def mask2former_b2_mod_family( + pretrained: bool = False, + path: str = "mask2former_b2_mod_family.pt", + num_classes: int = 6, +): + """Constructs a Mask2Former architecture with an EfficientNet-B2 backbone. + Mask2Former from `"Masked-attention Mask Transformer for Universal Image Segmentation" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + + """ + from .modules import Mask2FormerModel, create_mask2former + + # Create Mask2Former-B2 + mdl = create_mask2former( + backbone='efficientnet_b2', + pixel_decoder='multi_scale_deformable_attention', + predictor='multi_scale_masked_transformer_decoder', + num_classes=6, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['mask2former_b2_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + raise NotImplemented('Mask2Former implementation does not support finetuning to different class sizes yet.') + return mdl + + +def mask2former_b4_mod_family( + pretrained: bool = False, + path: str = "mask2former_b4_mod_family.pt", + num_classes: int = 6, +): + """Constructs a Mask2Former architecture with an EfficientNet-B4 backbone. + Mask2Former from `"Masked-attention Mask Transformer for Universal Image Segmentation" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 6, final layer will not be loaded from checkpoint + + """ + from .modules import Mask2FormerModel, create_mask2former + + # Create Mask2Former-B4 + mdl = create_mask2former( + backbone='efficientnet_b4', + pixel_decoder='multi_scale_deformable_attention', + predictor='multi_scale_masked_transformer_decoder', + num_classes=6, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['mask2former_b4_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + raise NotImplemented('Mask2Former implementation does not support finetuning to different class sizes yet.') + return mdl diff --git a/torchsig/models/spectrogram_models/mask2former/modules.py b/torchsig/models/spectrogram_models/mask2former/modules.py new file mode 100644 index 0000000..70d1436 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/modules.py @@ -0,0 +1,146 @@ +import torch +import numpy as np + +from .backbone import EffNetBackbone, ResNet50Backbone +from .pixel_decoder import MSDeformAttnPixelDecoder +from .predictor import MultiScaleMaskedTransformerDecoder + + +class Mask2FormerModel(torch.nn.Module): + def __init__( + self, + backbone: torch.nn.Module, + pixel_decoder: torch.nn.Module, + predictor: torch.nn.Module, + num_classes: int = 1, + ): + super().__init__() + self.backbone = backbone + self.pixel_decoder = pixel_decoder + self.predictor = predictor + self.num_classes = num_classes + + def forward(self, x): + # Propagate inputs through model layers + features = self.backbone(x) + mask_features, transformer_encoder_features, multi_scale_features = self.pixel_decoder.forward_features(features) + predictions = self.predictor(multi_scale_features, mask_features, mask=None) + return predictions + + +def create_backbone( + backbone: str = 'efficientnet_b0', +) -> torch.nn.Module: + if 'eff' in backbone: + if 'b0' in backbone or 'b2' in backbone or 'b4' in backbone: + network = EffNetBackbone(network=backbone) + else: + raise NotImplemented("Only B0, B2, and B4 EffNets are supported at this time") + elif backbone == 'resnet50': + network = ResNet50Backbone() + else: + raise NotImplemented("Only EfficientNet and ResNet-50 backbones supported at this time.") + return network + + +def create_pixel_decoder( + pixel_decoder: str = 'multi_scale_deformable_attention', + backbone: str = 'efficientnet_b0', + transformer_dropout: float = 0.0, + transformer_nheads: int = 8, + transformer_dim_feedforward: int = 2048, + transformer_enc_layers: int = 0, + conv_dim: int = 256, + mask_dim: int = 256, + norm: str = 'GN', + common_stride: int = 4, +) -> torch.nn.Module: + if pixel_decoder == 'multi_scale_deformable_attention': + network = MSDeformAttnPixelDecoder( + backbone=backbone, + transformer_dropout=transformer_dropout, + transformer_nheads=transformer_nheads, + transformer_dim_feedforward=transformer_dim_feedforward, + transformer_enc_layers=transformer_enc_layers, + conv_dim=conv_dim, + mask_dim=mask_dim, + norm=norm, + common_stride=common_stride, + ) + else: + raise NotImplemented("Only multi_scale_deformable_attention supported as a pixel decoder at this time.") + return network + + +def create_predictor( + predictor: str = 'multi_scale_masked_transformer_decoder', + in_channels: int = 256, + mask_classification: bool = True, + num_classes: int = 1, + hidden_dim: int = 256, + num_queries: int = 100, + nheads: int = 8, + dim_feedforward: int = 2048, + dec_layers: int = 10, + pre_norm: bool = False, + mask_dim: int = 256, + enforce_input_project: bool = False, +) -> torch.nn.Module: + if predictor == 'multi_scale_masked_transformer_decoder': + network = MultiScaleMaskedTransformerDecoder( + in_channels=in_channels, + mask_classification=mask_classification, + num_classes=num_classes, + hidden_dim=hidden_dim, + num_queries=num_queries, + nheads=nheads, + dim_feedforward=dim_feedforward, + dec_layers=dec_layers, + pre_norm=pre_norm, + mask_dim=mask_dim, + enforce_input_project=enforce_input_project, + ) + else: + raise NotImplemented("Only multi_scale_masked_transformer_decoder supported as predictor at this time.") + return network + + +def create_mask2former( + backbone: str = 'efficientnet_b0', + pixel_decoder: str = 'multi_scale_deformable_attention', + predictor: str = 'multi_scale_masked_transformer_decoder', + num_classes: int = 1, +) -> torch.nn.Module: + """ + Function used to build a Mask2Former network + + Args: + TODO + + Returns: + torch.nn.Module + """ + # Instantiate backbone + backbone_name = str(backbone) + backbone = create_backbone(backbone_name) + + # Instantiate pixel decoder + pixel_decoder = create_pixel_decoder( + pixel_decoder=pixel_decoder, + backbone=backbone_name, + ) + + # Instantiate predictor + predictor = create_predictor( + predictor=predictor, + num_classes=num_classes, + ) + + # Create full Mask2Former model + network = Mask2FormerModel( + backbone=backbone, + pixel_decoder=pixel_decoder, + predictor=predictor, + num_classes=num_classes + ) + return network \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/mask2former/ops/functions/__init__.py b/torchsig/models/spectrogram_models/mask2former/ops/functions/__init__.py new file mode 100644 index 0000000..2b06b5a --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/functions/__init__.py @@ -0,0 +1,13 @@ +# ------------------------------------------------------------------------------------------------ +# Deformable DETR +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------------------------------ +# Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +# ------------------------------------------------------------------------------------------------ + +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR + +from .ms_deform_attn_func import MSDeformAttnFunction + diff --git a/torchsig/models/spectrogram_models/mask2former/ops/functions/ms_deform_attn_func.py b/torchsig/models/spectrogram_models/mask2former/ops/functions/ms_deform_attn_func.py new file mode 100644 index 0000000..94a36ab --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/functions/ms_deform_attn_func.py @@ -0,0 +1,72 @@ +# ------------------------------------------------------------------------------------------------ +# Deformable DETR +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------------------------------ +# Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +# ------------------------------------------------------------------------------------------------ + +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR + +from __future__ import absolute_import +from __future__ import print_function +from __future__ import division + +import torch +import torch.nn.functional as F +from torch.autograd import Function +from torch.autograd.function import once_differentiable + +try: + import MultiScaleDeformableAttention as MSDA +except ModuleNotFoundError as e: + info_string = ( + "\n\nPlease compile MultiScaleDeformableAttention CUDA op with the following commands:\n" + "\t`cd mask2former/modeling/pixel_decoder/ops`\n" + "\t`sh make.sh`\n" + ) + raise ModuleNotFoundError(info_string) + + +class MSDeformAttnFunction(Function): + @staticmethod + def forward(ctx, value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, im2col_step): + ctx.im2col_step = im2col_step + output = MSDA.ms_deform_attn_forward( + value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, ctx.im2col_step) + ctx.save_for_backward(value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights = ctx.saved_tensors + grad_value, grad_sampling_loc, grad_attn_weight = \ + MSDA.ms_deform_attn_backward( + value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, grad_output, ctx.im2col_step) + + return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None + + +def ms_deform_attn_core_pytorch(value, value_spatial_shapes, sampling_locations, attention_weights): + # for debug and test only, + # need to use cuda version instead + N_, S_, M_, D_ = value.shape + _, Lq_, M_, L_, P_, _ = sampling_locations.shape + value_list = value.split([H_ * W_ for H_, W_ in value_spatial_shapes], dim=1) + sampling_grids = 2 * sampling_locations - 1 + sampling_value_list = [] + for lid_, (H_, W_) in enumerate(value_spatial_shapes): + # N_, H_*W_, M_, D_ -> N_, H_*W_, M_*D_ -> N_, M_*D_, H_*W_ -> N_*M_, D_, H_, W_ + value_l_ = value_list[lid_].flatten(2).transpose(1, 2).reshape(N_*M_, D_, H_, W_) + # N_, Lq_, M_, P_, 2 -> N_, M_, Lq_, P_, 2 -> N_*M_, Lq_, P_, 2 + sampling_grid_l_ = sampling_grids[:, :, :, lid_].transpose(1, 2).flatten(0, 1) + # N_*M_, D_, Lq_, P_ + sampling_value_l_ = F.grid_sample(value_l_, sampling_grid_l_, + mode='bilinear', padding_mode='zeros', align_corners=False) + sampling_value_list.append(sampling_value_l_) + # (N_, Lq_, M_, L_, P_) -> (N_, M_, Lq_, L_, P_) -> (N_, M_, 1, Lq_, L_*P_) + attention_weights = attention_weights.transpose(1, 2).reshape(N_*M_, 1, Lq_, L_*P_) + output = (torch.stack(sampling_value_list, dim=-2).flatten(-2) * attention_weights).sum(-1).view(N_, M_*D_, Lq_) + return output.transpose(1, 2).contiguous() diff --git a/torchsig/models/spectrogram_models/mask2former/ops/make.sh b/torchsig/models/spectrogram_models/mask2former/ops/make.sh new file mode 100755 index 0000000..7b38cdb --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/make.sh @@ -0,0 +1,13 @@ +#!/usr/bin/env bash +# ------------------------------------------------------------------------------------------------ +# Deformable DETR +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------------------------------ +# Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +# ------------------------------------------------------------------------------------------------ + +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR + +python setup.py build install diff --git a/torchsig/models/spectrogram_models/mask2former/ops/modules/__init__.py b/torchsig/models/spectrogram_models/mask2former/ops/modules/__init__.py new file mode 100644 index 0000000..6fdbf03 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/modules/__init__.py @@ -0,0 +1,12 @@ +# ------------------------------------------------------------------------------------------------ +# Deformable DETR +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------------------------------ +# Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +# ------------------------------------------------------------------------------------------------ + +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR + +from .ms_deform_attn import MSDeformAttn diff --git a/torchsig/models/spectrogram_models/mask2former/ops/modules/ms_deform_attn.py b/torchsig/models/spectrogram_models/mask2former/ops/modules/ms_deform_attn.py new file mode 100644 index 0000000..e7b4c42 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/modules/ms_deform_attn.py @@ -0,0 +1,125 @@ +# ------------------------------------------------------------------------------------------------ +# Deformable DETR +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------------------------------ +# Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +# ------------------------------------------------------------------------------------------------ + +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR + +from __future__ import absolute_import +from __future__ import print_function +from __future__ import division + +import warnings +import math + +import torch +from torch import nn +import torch.nn.functional as F +from torch.nn.init import xavier_uniform_, constant_ + +from ..functions import MSDeformAttnFunction +from ..functions.ms_deform_attn_func import ms_deform_attn_core_pytorch + + +def _is_power_of_2(n): + if (not isinstance(n, int)) or (n < 0): + raise ValueError("invalid input for _is_power_of_2: {} (type: {})".format(n, type(n))) + return (n & (n-1) == 0) and n != 0 + + +class MSDeformAttn(nn.Module): + def __init__(self, d_model=256, n_levels=4, n_heads=8, n_points=4): + """ + Multi-Scale Deformable Attention Module + :param d_model hidden dimension + :param n_levels number of feature levels + :param n_heads number of attention heads + :param n_points number of sampling points per attention head per feature level + """ + super().__init__() + if d_model % n_heads != 0: + raise ValueError('d_model must be divisible by n_heads, but got {} and {}'.format(d_model, n_heads)) + _d_per_head = d_model // n_heads + # you'd better set _d_per_head to a power of 2 which is more efficient in our CUDA implementation + if not _is_power_of_2(_d_per_head): + warnings.warn("You'd better set d_model in MSDeformAttn to make the dimension of each attention head a power of 2 " + "which is more efficient in our CUDA implementation.") + + self.im2col_step = 128 + + self.d_model = d_model + self.n_levels = n_levels + self.n_heads = n_heads + self.n_points = n_points + + self.sampling_offsets = nn.Linear(d_model, n_heads * n_levels * n_points * 2) + self.attention_weights = nn.Linear(d_model, n_heads * n_levels * n_points) + self.value_proj = nn.Linear(d_model, d_model) + self.output_proj = nn.Linear(d_model, d_model) + + self._reset_parameters() + + def _reset_parameters(self): + constant_(self.sampling_offsets.weight.data, 0.) + thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads) + grid_init = torch.stack([thetas.cos(), thetas.sin()], -1) + grid_init = (grid_init / grid_init.abs().max(-1, keepdim=True)[0]).view(self.n_heads, 1, 1, 2).repeat(1, self.n_levels, self.n_points, 1) + for i in range(self.n_points): + grid_init[:, :, i, :] *= i + 1 + with torch.no_grad(): + self.sampling_offsets.bias = nn.Parameter(grid_init.view(-1)) + constant_(self.attention_weights.weight.data, 0.) + constant_(self.attention_weights.bias.data, 0.) + xavier_uniform_(self.value_proj.weight.data) + constant_(self.value_proj.bias.data, 0.) + xavier_uniform_(self.output_proj.weight.data) + constant_(self.output_proj.bias.data, 0.) + + def forward(self, query, reference_points, input_flatten, input_spatial_shapes, input_level_start_index, input_padding_mask=None): + """ + :param query (N, Length_{query}, C) + :param reference_points (N, Length_{query}, n_levels, 2), range in [0, 1], top-left (0,0), bottom-right (1, 1), including padding area + or (N, Length_{query}, n_levels, 4), add additional (w, h) to form reference boxes + :param input_flatten (N, \sum_{l=0}^{L-1} H_l \cdot W_l, C) + :param input_spatial_shapes (n_levels, 2), [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})] + :param input_level_start_index (n_levels, ), [0, H_0*W_0, H_0*W_0+H_1*W_1, H_0*W_0+H_1*W_1+H_2*W_2, ..., H_0*W_0+H_1*W_1+...+H_{L-1}*W_{L-1}] + :param input_padding_mask (N, \sum_{l=0}^{L-1} H_l \cdot W_l), True for padding elements, False for non-padding elements + + :return output (N, Length_{query}, C) + """ + N, Len_q, _ = query.shape + N, Len_in, _ = input_flatten.shape + assert (input_spatial_shapes[:, 0] * input_spatial_shapes[:, 1]).sum() == Len_in + + value = self.value_proj(input_flatten) + if input_padding_mask is not None: + value = value.masked_fill(input_padding_mask[..., None], float(0)) + value = value.view(N, Len_in, self.n_heads, self.d_model // self.n_heads) + sampling_offsets = self.sampling_offsets(query).view(N, Len_q, self.n_heads, self.n_levels, self.n_points, 2) + attention_weights = self.attention_weights(query).view(N, Len_q, self.n_heads, self.n_levels * self.n_points) + attention_weights = F.softmax(attention_weights, -1).view(N, Len_q, self.n_heads, self.n_levels, self.n_points) + # N, Len_q, n_heads, n_levels, n_points, 2 + if reference_points.shape[-1] == 2: + offset_normalizer = torch.stack([input_spatial_shapes[..., 1], input_spatial_shapes[..., 0]], -1) + sampling_locations = reference_points[:, :, None, :, None, :] \ + + sampling_offsets / offset_normalizer[None, None, None, :, None, :] + elif reference_points.shape[-1] == 4: + sampling_locations = reference_points[:, :, None, :, None, :2] \ + + sampling_offsets / self.n_points * reference_points[:, :, None, :, None, 2:] * 0.5 + else: + raise ValueError( + 'Last dim of reference_points must be 2 or 4, but get {} instead.'.format(reference_points.shape[-1])) + try: + output = MSDeformAttnFunction.apply( + value, input_spatial_shapes, input_level_start_index, sampling_locations, attention_weights, self.im2col_step) + except: + # CPU + output = ms_deform_attn_core_pytorch(value, input_spatial_shapes, sampling_locations, attention_weights) + # # For FLOPs calculation only + # output = ms_deform_attn_core_pytorch(value, input_spatial_shapes, sampling_locations, attention_weights) + output = self.output_proj(output) + return output diff --git a/torchsig/models/spectrogram_models/mask2former/ops/setup.py b/torchsig/models/spectrogram_models/mask2former/ops/setup.py new file mode 100644 index 0000000..3b57ad3 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/setup.py @@ -0,0 +1,78 @@ +# ------------------------------------------------------------------------------------------------ +# Deformable DETR +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------------------------------ +# Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +# ------------------------------------------------------------------------------------------------ + +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR + +import os +import glob + +import torch + +from torch.utils.cpp_extension import CUDA_HOME +from torch.utils.cpp_extension import CppExtension +from torch.utils.cpp_extension import CUDAExtension + +from setuptools import find_packages +from setuptools import setup + +requirements = ["torch", "torchvision"] + +def get_extensions(): + this_dir = os.path.dirname(os.path.abspath(__file__)) + extensions_dir = os.path.join(this_dir, "src") + + main_file = glob.glob(os.path.join(extensions_dir, "*.cpp")) + source_cpu = glob.glob(os.path.join(extensions_dir, "cpu", "*.cpp")) + source_cuda = glob.glob(os.path.join(extensions_dir, "cuda", "*.cu")) + + sources = main_file + source_cpu + extension = CppExtension + extra_compile_args = {"cxx": []} + define_macros = [] + + # Force cuda since torch ask for a device, not if cuda is in fact available. + if (os.environ.get('FORCE_CUDA') or torch.cuda.is_available()) and CUDA_HOME is not None: + extension = CUDAExtension + sources += source_cuda + define_macros += [("WITH_CUDA", None)] + extra_compile_args["nvcc"] = [ + "-DCUDA_HAS_FP16=1", + "-D__CUDA_NO_HALF_OPERATORS__", + "-D__CUDA_NO_HALF_CONVERSIONS__", + "-D__CUDA_NO_HALF2_OPERATORS__", + ] + else: + if CUDA_HOME is None: + raise NotImplementedError('CUDA_HOME is None. Please set environment variable CUDA_HOME.') + else: + raise NotImplementedError('No CUDA runtime is found. Please set FORCE_CUDA=1 or test it by running torch.cuda.is_available().') + + sources = [os.path.join(extensions_dir, s) for s in sources] + include_dirs = [extensions_dir] + ext_modules = [ + extension( + "MultiScaleDeformableAttention", + sources, + include_dirs=include_dirs, + define_macros=define_macros, + extra_compile_args=extra_compile_args, + ) + ] + return ext_modules + +setup( + name="MultiScaleDeformableAttention", + version="1.0", + author="Weijie Su", + url="https://github.com/fundamentalvision/Deformable-DETR", + description="PyTorch Wrapper for CUDA Functions of Multi-Scale Deformable Attention", + packages=find_packages(exclude=("configs", "tests",)), + ext_modules=get_extensions(), + cmdclass={"build_ext": torch.utils.cpp_extension.BuildExtension}, +) diff --git a/torchsig/models/spectrogram_models/mask2former/ops/src/cpu/ms_deform_attn_cpu.cpp b/torchsig/models/spectrogram_models/mask2former/ops/src/cpu/ms_deform_attn_cpu.cpp new file mode 100644 index 0000000..48757e2 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/src/cpu/ms_deform_attn_cpu.cpp @@ -0,0 +1,46 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +/*! +* Copyright (c) Facebook, Inc. and its affiliates. +* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR +*/ + +#include + +#include +#include + + +at::Tensor +ms_deform_attn_cpu_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step) +{ + AT_ERROR("Not implement on cpu"); +} + +std::vector +ms_deform_attn_cpu_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step) +{ + AT_ERROR("Not implement on cpu"); +} + diff --git a/torchsig/models/spectrogram_models/mask2former/ops/src/cpu/ms_deform_attn_cpu.h b/torchsig/models/spectrogram_models/mask2former/ops/src/cpu/ms_deform_attn_cpu.h new file mode 100644 index 0000000..51bb27e --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/src/cpu/ms_deform_attn_cpu.h @@ -0,0 +1,38 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +/*! +* Copyright (c) Facebook, Inc. and its affiliates. +* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR +*/ + +#pragma once +#include + +at::Tensor +ms_deform_attn_cpu_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step); + +std::vector +ms_deform_attn_cpu_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step); + + diff --git a/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_attn_cuda.cu b/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_attn_cuda.cu new file mode 100644 index 0000000..0c465da --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_attn_cuda.cu @@ -0,0 +1,158 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +/*! +* Copyright (c) Facebook, Inc. and its affiliates. +* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR +*/ + +#include +#include "cuda/ms_deform_im2col_cuda.cuh" + +#include +#include +#include +#include + + +at::Tensor ms_deform_attn_cuda_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step) +{ + AT_ASSERTM(value.is_contiguous(), "value tensor has to be contiguous"); + AT_ASSERTM(spatial_shapes.is_contiguous(), "spatial_shapes tensor has to be contiguous"); + AT_ASSERTM(level_start_index.is_contiguous(), "level_start_index tensor has to be contiguous"); + AT_ASSERTM(sampling_loc.is_contiguous(), "sampling_loc tensor has to be contiguous"); + AT_ASSERTM(attn_weight.is_contiguous(), "attn_weight tensor has to be contiguous"); + + AT_ASSERTM(value.type().is_cuda(), "value must be a CUDA tensor"); + AT_ASSERTM(spatial_shapes.type().is_cuda(), "spatial_shapes must be a CUDA tensor"); + AT_ASSERTM(level_start_index.type().is_cuda(), "level_start_index must be a CUDA tensor"); + AT_ASSERTM(sampling_loc.type().is_cuda(), "sampling_loc must be a CUDA tensor"); + AT_ASSERTM(attn_weight.type().is_cuda(), "attn_weight must be a CUDA tensor"); + + const int batch = value.size(0); + const int spatial_size = value.size(1); + const int num_heads = value.size(2); + const int channels = value.size(3); + + const int num_levels = spatial_shapes.size(0); + + const int num_query = sampling_loc.size(1); + const int num_point = sampling_loc.size(4); + + const int im2col_step_ = std::min(batch, im2col_step); + + AT_ASSERTM(batch % im2col_step_ == 0, "batch(%d) must divide im2col_step(%d)", batch, im2col_step_); + + auto output = at::zeros({batch, num_query, num_heads, channels}, value.options()); + + const int batch_n = im2col_step_; + auto output_n = output.view({batch/im2col_step_, batch_n, num_query, num_heads, channels}); + auto per_value_size = spatial_size * num_heads * channels; + auto per_sample_loc_size = num_query * num_heads * num_levels * num_point * 2; + auto per_attn_weight_size = num_query * num_heads * num_levels * num_point; + for (int n = 0; n < batch/im2col_step_; ++n) + { + auto columns = output_n.select(0, n); + AT_DISPATCH_FLOATING_TYPES(value.type(), "ms_deform_attn_forward_cuda", ([&] { + ms_deformable_im2col_cuda(at::cuda::getCurrentCUDAStream(), + value.data() + n * im2col_step_ * per_value_size, + spatial_shapes.data(), + level_start_index.data(), + sampling_loc.data() + n * im2col_step_ * per_sample_loc_size, + attn_weight.data() + n * im2col_step_ * per_attn_weight_size, + batch_n, spatial_size, num_heads, channels, num_levels, num_query, num_point, + columns.data()); + + })); + } + + output = output.view({batch, num_query, num_heads*channels}); + + return output; +} + + +std::vector ms_deform_attn_cuda_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step) +{ + + AT_ASSERTM(value.is_contiguous(), "value tensor has to be contiguous"); + AT_ASSERTM(spatial_shapes.is_contiguous(), "spatial_shapes tensor has to be contiguous"); + AT_ASSERTM(level_start_index.is_contiguous(), "level_start_index tensor has to be contiguous"); + AT_ASSERTM(sampling_loc.is_contiguous(), "sampling_loc tensor has to be contiguous"); + AT_ASSERTM(attn_weight.is_contiguous(), "attn_weight tensor has to be contiguous"); + AT_ASSERTM(grad_output.is_contiguous(), "grad_output tensor has to be contiguous"); + + AT_ASSERTM(value.type().is_cuda(), "value must be a CUDA tensor"); + AT_ASSERTM(spatial_shapes.type().is_cuda(), "spatial_shapes must be a CUDA tensor"); + AT_ASSERTM(level_start_index.type().is_cuda(), "level_start_index must be a CUDA tensor"); + AT_ASSERTM(sampling_loc.type().is_cuda(), "sampling_loc must be a CUDA tensor"); + AT_ASSERTM(attn_weight.type().is_cuda(), "attn_weight must be a CUDA tensor"); + AT_ASSERTM(grad_output.type().is_cuda(), "grad_output must be a CUDA tensor"); + + const int batch = value.size(0); + const int spatial_size = value.size(1); + const int num_heads = value.size(2); + const int channels = value.size(3); + + const int num_levels = spatial_shapes.size(0); + + const int num_query = sampling_loc.size(1); + const int num_point = sampling_loc.size(4); + + const int im2col_step_ = std::min(batch, im2col_step); + + AT_ASSERTM(batch % im2col_step_ == 0, "batch(%d) must divide im2col_step(%d)", batch, im2col_step_); + + auto grad_value = at::zeros_like(value); + auto grad_sampling_loc = at::zeros_like(sampling_loc); + auto grad_attn_weight = at::zeros_like(attn_weight); + + const int batch_n = im2col_step_; + auto per_value_size = spatial_size * num_heads * channels; + auto per_sample_loc_size = num_query * num_heads * num_levels * num_point * 2; + auto per_attn_weight_size = num_query * num_heads * num_levels * num_point; + auto grad_output_n = grad_output.view({batch/im2col_step_, batch_n, num_query, num_heads, channels}); + + for (int n = 0; n < batch/im2col_step_; ++n) + { + auto grad_output_g = grad_output_n.select(0, n); + AT_DISPATCH_FLOATING_TYPES(value.type(), "ms_deform_attn_backward_cuda", ([&] { + ms_deformable_col2im_cuda(at::cuda::getCurrentCUDAStream(), + grad_output_g.data(), + value.data() + n * im2col_step_ * per_value_size, + spatial_shapes.data(), + level_start_index.data(), + sampling_loc.data() + n * im2col_step_ * per_sample_loc_size, + attn_weight.data() + n * im2col_step_ * per_attn_weight_size, + batch_n, spatial_size, num_heads, channels, num_levels, num_query, num_point, + grad_value.data() + n * im2col_step_ * per_value_size, + grad_sampling_loc.data() + n * im2col_step_ * per_sample_loc_size, + grad_attn_weight.data() + n * im2col_step_ * per_attn_weight_size); + + })); + } + + return { + grad_value, grad_sampling_loc, grad_attn_weight + }; +} \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_attn_cuda.h b/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_attn_cuda.h new file mode 100644 index 0000000..4f0658e --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_attn_cuda.h @@ -0,0 +1,35 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +/*! +* Copyright (c) Facebook, Inc. and its affiliates. +* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR +*/ + +#pragma once +#include + +at::Tensor ms_deform_attn_cuda_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step); + +std::vector ms_deform_attn_cuda_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step); + diff --git a/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_im2col_cuda.cuh b/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_im2col_cuda.cuh new file mode 100644 index 0000000..c04e0d4 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/src/cuda/ms_deform_im2col_cuda.cuh @@ -0,0 +1,1332 @@ +/*! +************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************** +* Modified from DCN (https://github.com/msracver/Deformable-ConvNets) +* Copyright (c) 2018 Microsoft +************************************************************************** +*/ + +/*! +* Copyright (c) Facebook, Inc. and its affiliates. +* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR +*/ + +#include +#include +#include + +#include +#include + +#include + +#define CUDA_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ + i < (n); \ + i += blockDim.x * gridDim.x) + +const int CUDA_NUM_THREADS = 1024; +inline int GET_BLOCKS(const int N, const int num_threads) +{ + return (N + num_threads - 1) / num_threads; +} + + +template +__device__ scalar_t ms_deform_attn_im2col_bilinear(const scalar_t* &bottom_data, + const int &height, const int &width, const int &nheads, const int &channels, + const scalar_t &h, const scalar_t &w, const int &m, const int &c) +{ + const int h_low = floor(h); + const int w_low = floor(w); + const int h_high = h_low + 1; + const int w_high = w_low + 1; + + const scalar_t lh = h - h_low; + const scalar_t lw = w - w_low; + const scalar_t hh = 1 - lh, hw = 1 - lw; + + const int w_stride = nheads * channels; + const int h_stride = width * w_stride; + const int h_low_ptr_offset = h_low * h_stride; + const int h_high_ptr_offset = h_low_ptr_offset + h_stride; + const int w_low_ptr_offset = w_low * w_stride; + const int w_high_ptr_offset = w_low_ptr_offset + w_stride; + const int base_ptr = m * channels + c; + + scalar_t v1 = 0; + if (h_low >= 0 && w_low >= 0) + { + const int ptr1 = h_low_ptr_offset + w_low_ptr_offset + base_ptr; + v1 = bottom_data[ptr1]; + } + scalar_t v2 = 0; + if (h_low >= 0 && w_high <= width - 1) + { + const int ptr2 = h_low_ptr_offset + w_high_ptr_offset + base_ptr; + v2 = bottom_data[ptr2]; + } + scalar_t v3 = 0; + if (h_high <= height - 1 && w_low >= 0) + { + const int ptr3 = h_high_ptr_offset + w_low_ptr_offset + base_ptr; + v3 = bottom_data[ptr3]; + } + scalar_t v4 = 0; + if (h_high <= height - 1 && w_high <= width - 1) + { + const int ptr4 = h_high_ptr_offset + w_high_ptr_offset + base_ptr; + v4 = bottom_data[ptr4]; + } + + const scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw; + + const scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + return val; +} + + +template +__device__ void ms_deform_attn_col2im_bilinear(const scalar_t* &bottom_data, + const int &height, const int &width, const int &nheads, const int &channels, + const scalar_t &h, const scalar_t &w, const int &m, const int &c, + const scalar_t &top_grad, + const scalar_t &attn_weight, + scalar_t* &grad_value, + scalar_t* grad_sampling_loc, + scalar_t* grad_attn_weight) +{ + const int h_low = floor(h); + const int w_low = floor(w); + const int h_high = h_low + 1; + const int w_high = w_low + 1; + + const scalar_t lh = h - h_low; + const scalar_t lw = w - w_low; + const scalar_t hh = 1 - lh, hw = 1 - lw; + + const int w_stride = nheads * channels; + const int h_stride = width * w_stride; + const int h_low_ptr_offset = h_low * h_stride; + const int h_high_ptr_offset = h_low_ptr_offset + h_stride; + const int w_low_ptr_offset = w_low * w_stride; + const int w_high_ptr_offset = w_low_ptr_offset + w_stride; + const int base_ptr = m * channels + c; + + const scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw; + const scalar_t top_grad_value = top_grad * attn_weight; + scalar_t grad_h_weight = 0, grad_w_weight = 0; + + scalar_t v1 = 0; + if (h_low >= 0 && w_low >= 0) + { + const int ptr1 = h_low_ptr_offset + w_low_ptr_offset + base_ptr; + v1 = bottom_data[ptr1]; + grad_h_weight -= hw * v1; + grad_w_weight -= hh * v1; + atomicAdd(grad_value+ptr1, w1*top_grad_value); + } + scalar_t v2 = 0; + if (h_low >= 0 && w_high <= width - 1) + { + const int ptr2 = h_low_ptr_offset + w_high_ptr_offset + base_ptr; + v2 = bottom_data[ptr2]; + grad_h_weight -= lw * v2; + grad_w_weight += hh * v2; + atomicAdd(grad_value+ptr2, w2*top_grad_value); + } + scalar_t v3 = 0; + if (h_high <= height - 1 && w_low >= 0) + { + const int ptr3 = h_high_ptr_offset + w_low_ptr_offset + base_ptr; + v3 = bottom_data[ptr3]; + grad_h_weight += hw * v3; + grad_w_weight -= lh * v3; + atomicAdd(grad_value+ptr3, w3*top_grad_value); + } + scalar_t v4 = 0; + if (h_high <= height - 1 && w_high <= width - 1) + { + const int ptr4 = h_high_ptr_offset + w_high_ptr_offset + base_ptr; + v4 = bottom_data[ptr4]; + grad_h_weight += lw * v4; + grad_w_weight += lh * v4; + atomicAdd(grad_value+ptr4, w4*top_grad_value); + } + + const scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + *grad_attn_weight = top_grad * val; + *grad_sampling_loc = width * grad_w_weight * top_grad_value; + *(grad_sampling_loc + 1) = height * grad_h_weight * top_grad_value; +} + + +template +__device__ void ms_deform_attn_col2im_bilinear_gm(const scalar_t* &bottom_data, + const int &height, const int &width, const int &nheads, const int &channels, + const scalar_t &h, const scalar_t &w, const int &m, const int &c, + const scalar_t &top_grad, + const scalar_t &attn_weight, + scalar_t* &grad_value, + scalar_t* grad_sampling_loc, + scalar_t* grad_attn_weight) +{ + const int h_low = floor(h); + const int w_low = floor(w); + const int h_high = h_low + 1; + const int w_high = w_low + 1; + + const scalar_t lh = h - h_low; + const scalar_t lw = w - w_low; + const scalar_t hh = 1 - lh, hw = 1 - lw; + + const int w_stride = nheads * channels; + const int h_stride = width * w_stride; + const int h_low_ptr_offset = h_low * h_stride; + const int h_high_ptr_offset = h_low_ptr_offset + h_stride; + const int w_low_ptr_offset = w_low * w_stride; + const int w_high_ptr_offset = w_low_ptr_offset + w_stride; + const int base_ptr = m * channels + c; + + const scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw; + const scalar_t top_grad_value = top_grad * attn_weight; + scalar_t grad_h_weight = 0, grad_w_weight = 0; + + scalar_t v1 = 0; + if (h_low >= 0 && w_low >= 0) + { + const int ptr1 = h_low_ptr_offset + w_low_ptr_offset + base_ptr; + v1 = bottom_data[ptr1]; + grad_h_weight -= hw * v1; + grad_w_weight -= hh * v1; + atomicAdd(grad_value+ptr1, w1*top_grad_value); + } + scalar_t v2 = 0; + if (h_low >= 0 && w_high <= width - 1) + { + const int ptr2 = h_low_ptr_offset + w_high_ptr_offset + base_ptr; + v2 = bottom_data[ptr2]; + grad_h_weight -= lw * v2; + grad_w_weight += hh * v2; + atomicAdd(grad_value+ptr2, w2*top_grad_value); + } + scalar_t v3 = 0; + if (h_high <= height - 1 && w_low >= 0) + { + const int ptr3 = h_high_ptr_offset + w_low_ptr_offset + base_ptr; + v3 = bottom_data[ptr3]; + grad_h_weight += hw * v3; + grad_w_weight -= lh * v3; + atomicAdd(grad_value+ptr3, w3*top_grad_value); + } + scalar_t v4 = 0; + if (h_high <= height - 1 && w_high <= width - 1) + { + const int ptr4 = h_high_ptr_offset + w_high_ptr_offset + base_ptr; + v4 = bottom_data[ptr4]; + grad_h_weight += lw * v4; + grad_w_weight += lh * v4; + atomicAdd(grad_value+ptr4, w4*top_grad_value); + } + + const scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + atomicAdd(grad_attn_weight, top_grad * val); + atomicAdd(grad_sampling_loc, width * grad_w_weight * top_grad_value); + atomicAdd(grad_sampling_loc + 1, height * grad_h_weight * top_grad_value); +} + + +template +__global__ void ms_deformable_im2col_gpu_kernel(const int n, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *data_col) +{ + CUDA_KERNEL_LOOP(index, n) + { + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + scalar_t *data_col_ptr = data_col + index; + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + scalar_t col = 0; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const scalar_t *data_value_ptr = data_value + (data_value_ptr_init_offset + level_start_id * qid_stride); + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + col += ms_deform_attn_im2col_bilinear(data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col) * weight; + } + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + } + } + *data_col_ptr = col; + } +} + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + __shared__ scalar_t cache_grad_sampling_loc[blockSize * 2]; + __shared__ scalar_t cache_grad_attn_weight[blockSize]; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + if (tid == 0) + { + scalar_t _grad_w=cache_grad_sampling_loc[0], _grad_h=cache_grad_sampling_loc[1], _grad_a=cache_grad_attn_weight[0]; + int sid=2; + for (unsigned int tid = 1; tid < blockSize; ++tid) + { + _grad_w += cache_grad_sampling_loc[sid]; + _grad_h += cache_grad_sampling_loc[sid + 1]; + _grad_a += cache_grad_attn_weight[tid]; + sid += 2; + } + + + *grad_sampling_loc = _grad_w; + *(grad_sampling_loc + 1) = _grad_h; + *grad_attn_weight = _grad_a; + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + __shared__ scalar_t cache_grad_sampling_loc[blockSize * 2]; + __shared__ scalar_t cache_grad_attn_weight[blockSize]; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + + for (unsigned int s=blockSize/2; s>0; s>>=1) + { + if (tid < s) { + const unsigned int xid1 = tid << 1; + const unsigned int xid2 = (tid + s) << 1; + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + s]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1]; + } + __syncthreads(); + } + + if (tid == 0) + { + *grad_sampling_loc = cache_grad_sampling_loc[0]; + *(grad_sampling_loc + 1) = cache_grad_sampling_loc[1]; + *grad_attn_weight = cache_grad_attn_weight[0]; + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_reduce_v1(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + extern __shared__ int _s[]; + scalar_t* cache_grad_sampling_loc = (scalar_t*)_s; + scalar_t* cache_grad_attn_weight = cache_grad_sampling_loc + 2 * blockDim.x; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + if (tid == 0) + { + scalar_t _grad_w=cache_grad_sampling_loc[0], _grad_h=cache_grad_sampling_loc[1], _grad_a=cache_grad_attn_weight[0]; + int sid=2; + for (unsigned int tid = 1; tid < blockDim.x; ++tid) + { + _grad_w += cache_grad_sampling_loc[sid]; + _grad_h += cache_grad_sampling_loc[sid + 1]; + _grad_a += cache_grad_attn_weight[tid]; + sid += 2; + } + + + *grad_sampling_loc = _grad_w; + *(grad_sampling_loc + 1) = _grad_h; + *grad_attn_weight = _grad_a; + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_reduce_v2(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + extern __shared__ int _s[]; + scalar_t* cache_grad_sampling_loc = (scalar_t*)_s; + scalar_t* cache_grad_attn_weight = cache_grad_sampling_loc + 2 * blockDim.x; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + + for (unsigned int s=blockDim.x/2, spre=blockDim.x; s>0; s>>=1, spre>>=1) + { + if (tid < s) { + const unsigned int xid1 = tid << 1; + const unsigned int xid2 = (tid + s) << 1; + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + s]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1]; + if (tid + (s << 1) < spre) + { + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + (s << 1)]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2 + (s << 1)]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1 + (s << 1)]; + } + } + __syncthreads(); + } + + if (tid == 0) + { + *grad_sampling_loc = cache_grad_sampling_loc[0]; + *(grad_sampling_loc + 1) = cache_grad_sampling_loc[1]; + *grad_attn_weight = cache_grad_attn_weight[0]; + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + +template +__global__ void ms_deformable_col2im_gpu_kernel_shm_reduce_v2_multi_blocks(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + extern __shared__ int _s[]; + scalar_t* cache_grad_sampling_loc = (scalar_t*)_s; + scalar_t* cache_grad_attn_weight = cache_grad_sampling_loc + 2 * blockDim.x; + unsigned int tid = threadIdx.x; + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + *(cache_grad_sampling_loc+(threadIdx.x << 1)) = 0; + *(cache_grad_sampling_loc+((threadIdx.x << 1) + 1)) = 0; + *(cache_grad_attn_weight+threadIdx.x)=0; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + cache_grad_sampling_loc+(threadIdx.x << 1), cache_grad_attn_weight+threadIdx.x); + } + + __syncthreads(); + + for (unsigned int s=blockDim.x/2, spre=blockDim.x; s>0; s>>=1, spre>>=1) + { + if (tid < s) { + const unsigned int xid1 = tid << 1; + const unsigned int xid2 = (tid + s) << 1; + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + s]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1]; + if (tid + (s << 1) < spre) + { + cache_grad_attn_weight[tid] += cache_grad_attn_weight[tid + (s << 1)]; + cache_grad_sampling_loc[xid1] += cache_grad_sampling_loc[xid2 + (s << 1)]; + cache_grad_sampling_loc[xid1 + 1] += cache_grad_sampling_loc[xid2 + 1 + (s << 1)]; + } + } + __syncthreads(); + } + + if (tid == 0) + { + atomicAdd(grad_sampling_loc, cache_grad_sampling_loc[0]); + atomicAdd(grad_sampling_loc + 1, cache_grad_sampling_loc[1]); + atomicAdd(grad_attn_weight, cache_grad_attn_weight[0]); + } + __syncthreads(); + + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + + +template +__global__ void ms_deformable_col2im_gpu_kernel_gm(const int n, + const scalar_t *grad_col, + const scalar_t *data_value, + const int64_t *data_spatial_shapes, + const int64_t *data_level_start_index, + const scalar_t *data_sampling_loc, + const scalar_t *data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t *grad_value, + scalar_t *grad_sampling_loc, + scalar_t *grad_attn_weight) +{ + CUDA_KERNEL_LOOP(index, n) + { + int _temp = index; + const int c_col = _temp % channels; + _temp /= channels; + const int sampling_index = _temp; + const int m_col = _temp % num_heads; + _temp /= num_heads; + const int q_col = _temp % num_query; + _temp /= num_query; + const int b_col = _temp; + + const scalar_t top_grad = grad_col[index]; + + int data_weight_ptr = sampling_index * num_levels * num_point; + int data_loc_w_ptr = data_weight_ptr << 1; + const int grad_sampling_ptr = data_weight_ptr; + grad_sampling_loc += grad_sampling_ptr << 1; + grad_attn_weight += grad_sampling_ptr; + const int grad_weight_stride = 1; + const int grad_loc_stride = 2; + const int qid_stride = num_heads * channels; + const int data_value_ptr_init_offset = b_col * spatial_size * qid_stride; + + for (int l_col=0; l_col < num_levels; ++l_col) + { + const int level_start_id = data_level_start_index[l_col]; + const int spatial_h_ptr = l_col << 1; + const int spatial_h = data_spatial_shapes[spatial_h_ptr]; + const int spatial_w = data_spatial_shapes[spatial_h_ptr + 1]; + const int value_ptr_offset = data_value_ptr_init_offset + level_start_id * qid_stride; + const scalar_t *data_value_ptr = data_value + value_ptr_offset; + scalar_t *grad_value_ptr = grad_value + value_ptr_offset; + + for (int p_col=0; p_col < num_point; ++p_col) + { + const scalar_t loc_w = data_sampling_loc[data_loc_w_ptr]; + const scalar_t loc_h = data_sampling_loc[data_loc_w_ptr + 1]; + const scalar_t weight = data_attn_weight[data_weight_ptr]; + + const scalar_t h_im = loc_h * spatial_h - 0.5; + const scalar_t w_im = loc_w * spatial_w - 0.5; + if (h_im > -1 && w_im > -1 && h_im < spatial_h && w_im < spatial_w) + { + ms_deform_attn_col2im_bilinear_gm( + data_value_ptr, spatial_h, spatial_w, num_heads, channels, h_im, w_im, m_col, c_col, + top_grad, weight, grad_value_ptr, + grad_sampling_loc, grad_attn_weight); + } + data_weight_ptr += 1; + data_loc_w_ptr += 2; + grad_attn_weight += grad_weight_stride; + grad_sampling_loc += grad_loc_stride; + } + } + } +} + + +template +void ms_deformable_im2col_cuda(cudaStream_t stream, + const scalar_t* data_value, + const int64_t* data_spatial_shapes, + const int64_t* data_level_start_index, + const scalar_t* data_sampling_loc, + const scalar_t* data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t* data_col) +{ + const int num_kernels = batch_size * num_query * num_heads * channels; + const int num_actual_kernels = batch_size * num_query * num_heads * channels; + const int num_threads = CUDA_NUM_THREADS; + ms_deformable_im2col_gpu_kernel + <<>>( + num_kernels, data_value, data_spatial_shapes, data_level_start_index, data_sampling_loc, data_attn_weight, + batch_size, spatial_size, num_heads, channels, num_levels, num_query, num_point, data_col); + + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in ms_deformable_im2col_cuda: %s\n", cudaGetErrorString(err)); + } + +} + +template +void ms_deformable_col2im_cuda(cudaStream_t stream, + const scalar_t* grad_col, + const scalar_t* data_value, + const int64_t * data_spatial_shapes, + const int64_t * data_level_start_index, + const scalar_t * data_sampling_loc, + const scalar_t * data_attn_weight, + const int batch_size, + const int spatial_size, + const int num_heads, + const int channels, + const int num_levels, + const int num_query, + const int num_point, + scalar_t* grad_value, + scalar_t* grad_sampling_loc, + scalar_t* grad_attn_weight) +{ + const int num_threads = (channels > CUDA_NUM_THREADS)?CUDA_NUM_THREADS:channels; + const int num_kernels = batch_size * num_query * num_heads * channels; + const int num_actual_kernels = batch_size * num_query * num_heads * channels; + if (channels > 1024) + { + if ((channels & 1023) == 0) + { + ms_deformable_col2im_gpu_kernel_shm_reduce_v2_multi_blocks + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + } + else + { + ms_deformable_col2im_gpu_kernel_gm + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + } + } + else{ + switch(channels) + { + case 1: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 2: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 4: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 8: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 16: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 32: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 64: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 128: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 256: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 512: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + case 1024: + ms_deformable_col2im_gpu_kernel_shm_blocksize_aware_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + break; + default: + if (channels < 64) + { + ms_deformable_col2im_gpu_kernel_shm_reduce_v1 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + } + else + { + ms_deformable_col2im_gpu_kernel_shm_reduce_v2 + <<>>( + num_kernels, + grad_col, + data_value, + data_spatial_shapes, + data_level_start_index, + data_sampling_loc, + data_attn_weight, + batch_size, + spatial_size, + num_heads, + channels, + num_levels, + num_query, + num_point, + grad_value, + grad_sampling_loc, + grad_attn_weight); + } + } + } + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in ms_deformable_col2im_cuda: %s\n", cudaGetErrorString(err)); + } + +} \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/mask2former/ops/src/ms_deform_attn.h b/torchsig/models/spectrogram_models/mask2former/ops/src/ms_deform_attn.h new file mode 100644 index 0000000..2f80a1b --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/src/ms_deform_attn.h @@ -0,0 +1,67 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +/*! +* Copyright (c) Facebook, Inc. and its affiliates. +* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR +*/ + +#pragma once + +#include "cpu/ms_deform_attn_cpu.h" + +#ifdef WITH_CUDA +#include "cuda/ms_deform_attn_cuda.h" +#endif + + +at::Tensor +ms_deform_attn_forward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const int im2col_step) +{ + if (value.type().is_cuda()) + { +#ifdef WITH_CUDA + return ms_deform_attn_cuda_forward( + value, spatial_shapes, level_start_index, sampling_loc, attn_weight, im2col_step); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + AT_ERROR("Not implemented on the CPU"); +} + +std::vector +ms_deform_attn_backward( + const at::Tensor &value, + const at::Tensor &spatial_shapes, + const at::Tensor &level_start_index, + const at::Tensor &sampling_loc, + const at::Tensor &attn_weight, + const at::Tensor &grad_output, + const int im2col_step) +{ + if (value.type().is_cuda()) + { +#ifdef WITH_CUDA + return ms_deform_attn_cuda_backward( + value, spatial_shapes, level_start_index, sampling_loc, attn_weight, grad_output, im2col_step); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + AT_ERROR("Not implemented on the CPU"); +} + diff --git a/torchsig/models/spectrogram_models/mask2former/ops/src/vision.cpp b/torchsig/models/spectrogram_models/mask2former/ops/src/vision.cpp new file mode 100644 index 0000000..4a08821 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/src/vision.cpp @@ -0,0 +1,21 @@ +/*! +************************************************************************************************** +* Deformable DETR +* Copyright (c) 2020 SenseTime. All Rights Reserved. +* Licensed under the Apache License, Version 2.0 [see LICENSE for details] +************************************************************************************************** +* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +************************************************************************************************** +*/ + +/*! +* Copyright (c) Facebook, Inc. and its affiliates. +* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR +*/ + +#include "ms_deform_attn.h" + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("ms_deform_attn_forward", &ms_deform_attn_forward, "ms_deform_attn_forward"); + m.def("ms_deform_attn_backward", &ms_deform_attn_backward, "ms_deform_attn_backward"); +} diff --git a/torchsig/models/spectrogram_models/mask2former/ops/test.py b/torchsig/models/spectrogram_models/mask2former/ops/test.py new file mode 100644 index 0000000..6e1b545 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/ops/test.py @@ -0,0 +1,92 @@ +# ------------------------------------------------------------------------------------------------ +# Deformable DETR +# Copyright (c) 2020 SenseTime. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 [see LICENSE for details] +# ------------------------------------------------------------------------------------------------ +# Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 +# ------------------------------------------------------------------------------------------------ + +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR + +from __future__ import absolute_import +from __future__ import print_function +from __future__ import division + +import time +import torch +import torch.nn as nn +from torch.autograd import gradcheck + +from functions.ms_deform_attn_func import MSDeformAttnFunction, ms_deform_attn_core_pytorch + + +N, M, D = 1, 2, 2 +Lq, L, P = 2, 2, 2 +shapes = torch.as_tensor([(6, 4), (3, 2)], dtype=torch.long).cuda() +level_start_index = torch.cat((shapes.new_zeros((1, )), shapes.prod(1).cumsum(0)[:-1])) +S = sum([(H*W).item() for H, W in shapes]) + + +torch.manual_seed(3) + + +@torch.no_grad() +def check_forward_equal_with_pytorch_double(): + value = torch.rand(N, S, M, D).cuda() * 0.01 + sampling_locations = torch.rand(N, Lq, M, L, P, 2).cuda() + attention_weights = torch.rand(N, Lq, M, L, P).cuda() + 1e-5 + attention_weights /= attention_weights.sum(-1, keepdim=True).sum(-2, keepdim=True) + im2col_step = 2 + output_pytorch = ms_deform_attn_core_pytorch(value.double(), shapes, sampling_locations.double(), attention_weights.double()).detach().cpu() + output_cuda = MSDeformAttnFunction.apply(value.double(), shapes, level_start_index, sampling_locations.double(), attention_weights.double(), im2col_step).detach().cpu() + fwdok = torch.allclose(output_cuda, output_pytorch) + max_abs_err = (output_cuda - output_pytorch).abs().max() + max_rel_err = ((output_cuda - output_pytorch).abs() / output_pytorch.abs()).max() + + print(f'* {fwdok} check_forward_equal_with_pytorch_double: max_abs_err {max_abs_err:.2e} max_rel_err {max_rel_err:.2e}') + + +@torch.no_grad() +def check_forward_equal_with_pytorch_float(): + value = torch.rand(N, S, M, D).cuda() * 0.01 + sampling_locations = torch.rand(N, Lq, M, L, P, 2).cuda() + attention_weights = torch.rand(N, Lq, M, L, P).cuda() + 1e-5 + attention_weights /= attention_weights.sum(-1, keepdim=True).sum(-2, keepdim=True) + im2col_step = 2 + output_pytorch = ms_deform_attn_core_pytorch(value, shapes, sampling_locations, attention_weights).detach().cpu() + output_cuda = MSDeformAttnFunction.apply(value, shapes, level_start_index, sampling_locations, attention_weights, im2col_step).detach().cpu() + fwdok = torch.allclose(output_cuda, output_pytorch, rtol=1e-2, atol=1e-3) + max_abs_err = (output_cuda - output_pytorch).abs().max() + max_rel_err = ((output_cuda - output_pytorch).abs() / output_pytorch.abs()).max() + + print(f'* {fwdok} check_forward_equal_with_pytorch_float: max_abs_err {max_abs_err:.2e} max_rel_err {max_rel_err:.2e}') + + +def check_gradient_numerical(channels=4, grad_value=True, grad_sampling_loc=True, grad_attn_weight=True): + + value = torch.rand(N, S, M, channels).cuda() * 0.01 + sampling_locations = torch.rand(N, Lq, M, L, P, 2).cuda() + attention_weights = torch.rand(N, Lq, M, L, P).cuda() + 1e-5 + attention_weights /= attention_weights.sum(-1, keepdim=True).sum(-2, keepdim=True) + im2col_step = 2 + func = MSDeformAttnFunction.apply + + value.requires_grad = grad_value + sampling_locations.requires_grad = grad_sampling_loc + attention_weights.requires_grad = grad_attn_weight + + gradok = gradcheck(func, (value.double(), shapes, level_start_index, sampling_locations.double(), attention_weights.double(), im2col_step)) + + print(f'* {gradok} check_gradient_numerical(D={channels})') + + +if __name__ == '__main__': + check_forward_equal_with_pytorch_double() + check_forward_equal_with_pytorch_float() + + for channels in [30, 32, 64, 71, 1025, 2048, 3096]: + check_gradient_numerical(channels, True, True, True) + + + diff --git a/torchsig/models/spectrogram_models/mask2former/pixel_decoder.py b/torchsig/models/spectrogram_models/mask2former/pixel_decoder.py new file mode 100644 index 0000000..992ae5e --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/pixel_decoder.py @@ -0,0 +1,724 @@ +import math +import torch +import warnings +import numpy as np +from torch import nn +import torch.nn.functional as F +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.nn.init import xavier_uniform_, constant_, uniform_, normal_ +from collections import namedtuple +from typing import Dict, Optional, Union, Callable, List + +try: + import MultiScaleDeformableAttention as MSDA +except ModuleNotFoundError as e: + info_string = ( + "\n\nPlease compile MultiScaleDeformableAttention CUDA op with the following commands:\n" + "\t`cd spdata/spdata/models/spectrogram_models/mask2former/ops/`\n" + "\t`sh make.sh`\n" + ) + raise ModuleNotFoundError(info_string) + + +class MSDeformAttnFunction(Function): + @staticmethod + def forward(ctx, value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, im2col_step): + ctx.im2col_step = im2col_step + output = MSDA.ms_deform_attn_forward( + value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, ctx.im2col_step) + ctx.save_for_backward(value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights = ctx.saved_tensors + grad_value, grad_sampling_loc, grad_attn_weight = \ + MSDA.ms_deform_attn_backward( + value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, grad_output, ctx.im2col_step) + + return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None + + +def ms_deform_attn_core_pytorch(value, value_spatial_shapes, sampling_locations, attention_weights): + # for debug and test only, + # need to use cuda version instead + N_, S_, M_, D_ = value.shape + _, Lq_, M_, L_, P_, _ = sampling_locations.shape + value_list = value.split([H_ * W_ for H_, W_ in value_spatial_shapes], dim=1) + sampling_grids = 2 * sampling_locations - 1 + sampling_value_list = [] + for lid_, (H_, W_) in enumerate(value_spatial_shapes): + # N_, H_*W_, M_, D_ -> N_, H_*W_, M_*D_ -> N_, M_*D_, H_*W_ -> N_*M_, D_, H_, W_ + value_l_ = value_list[lid_].flatten(2).transpose(1, 2).reshape(N_*M_, D_, H_, W_) + # N_, Lq_, M_, P_, 2 -> N_, M_, Lq_, P_, 2 -> N_*M_, Lq_, P_, 2 + sampling_grid_l_ = sampling_grids[:, :, :, lid_].transpose(1, 2).flatten(0, 1) + # N_*M_, D_, Lq_, P_ + sampling_value_l_ = F.grid_sample(value_l_, sampling_grid_l_, + mode='bilinear', padding_mode='zeros', align_corners=False) + sampling_value_list.append(sampling_value_l_) + # (N_, Lq_, M_, L_, P_) -> (N_, M_, Lq_, L_, P_) -> (N_, M_, 1, Lq_, L_*P_) + attention_weights = attention_weights.transpose(1, 2).reshape(N_*M_, 1, Lq_, L_*P_) + output = (torch.stack(sampling_value_list, dim=-2).flatten(-2) * attention_weights).sum(-1).view(N_, M_*D_, Lq_) + return output.transpose(1, 2).contiguous() + + +class Conv2d(torch.nn.Conv2d): + """ + A wrapper around :class:`torch.nn.Conv2d` to support empty inputs and more features. + """ + def __init__(self, *args, **kwargs): + """ + Extra keyword arguments supported in addition to those in `torch.nn.Conv2d`: + + Args: + norm (nn.Module, optional): a normalization layer + activation (callable(Tensor) -> Tensor): a callable activation function + + It assumes that norm layer is used before activation. + """ + norm = kwargs.pop("norm", None) + activation = kwargs.pop("activation", None) + super().__init__(*args, **kwargs) + + self.norm = norm + self.activation = activation + + def forward(self, x): + # torchscript does not support SyncBatchNorm yet + # https://github.com/pytorch/pytorch/issues/40507 + # and we skip these codes in torchscript since: + # 1. currently we only support torchscript in evaluation mode + # 2. features needed by exporting module to torchscript are added in PyTorch 1.6 or + # later version, `Conv2d` in these PyTorch versions has already supported empty inputs. + if not torch.jit.is_scripting(): + if x.numel() == 0 and self.training: + # https://github.com/pytorch/pytorch/issues/12013 + assert not isinstance( + self.norm, torch.nn.SyncBatchNorm + ), "SyncBatchNorm does not support empty inputs!" + + x = F.conv2d( + x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups + ) + if self.norm is not None: + x = self.norm(x) + if self.activation is not None: + x = self.activation(x) + return x + + +def _get_clones(module, N): + return nn.ModuleList([copy.deepcopy(module) for i in range(N)]) + + +def _get_activation_fn(activation): + """Return an activation function given a string""" + if activation == "relu": + return F.relu + if activation == "gelu": + return F.gelu + if activation == "glu": + return F.glu + raise RuntimeError(f"activation should be relu/gelu, not {activation}.") + + +class ShapeSpec(namedtuple("_ShapeSpec", ["channels", "height", "width", "stride"])): + """ + A simple structure that contains basic shape specification about a tensor. + It is often used as the auxiliary inputs/outputs of models, + to complement the lack of shape inference ability among pytorch modules. + Attributes: + channels: + height: + width: + stride: + """ + + def __new__(cls, channels=None, height=None, width=None, stride=None): + return super().__new__(cls, channels, height, width, stride) + + +def _is_power_of_2(n): + if (not isinstance(n, int)) or (n < 0): + raise ValueError("invalid input for _is_power_of_2: {} (type: {})".format(n, type(n))) + return (n & (n-1) == 0) and n != 0 + + +class MSDeformAttn(nn.Module): + def __init__(self, d_model=256, n_levels=4, n_heads=8, n_points=4): + """ + Multi-Scale Deformable Attention Module + :param d_model hidden dimension + :param n_levels number of feature levels + :param n_heads number of attention heads + :param n_points number of sampling points per attention head per feature level + """ + super().__init__() + if d_model % n_heads != 0: + raise ValueError('d_model must be divisible by n_heads, but got {} and {}'.format(d_model, n_heads)) + _d_per_head = d_model // n_heads + # you'd better set _d_per_head to a power of 2 which is more efficient in our CUDA implementation + if not _is_power_of_2(_d_per_head): + warnings.warn("You'd better set d_model in MSDeformAttn to make the dimension of each attention head a power of 2 " + "which is more efficient in our CUDA implementation.") + + self.im2col_step = 128 + + self.d_model = d_model + self.n_levels = n_levels + self.n_heads = n_heads + self.n_points = n_points + + self.sampling_offsets = nn.Linear(d_model, n_heads * n_levels * n_points * 2) + self.attention_weights = nn.Linear(d_model, n_heads * n_levels * n_points) + self.value_proj = nn.Linear(d_model, d_model) + self.output_proj = nn.Linear(d_model, d_model) + + self._reset_parameters() + + def _reset_parameters(self): + constant_(self.sampling_offsets.weight.data, 0.) + thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads) + grid_init = torch.stack([thetas.cos(), thetas.sin()], -1) + grid_init = (grid_init / grid_init.abs().max(-1, keepdim=True)[0]).view(self.n_heads, 1, 1, 2).repeat(1, self.n_levels, self.n_points, 1) + for i in range(self.n_points): + grid_init[:, :, i, :] *= i + 1 + with torch.no_grad(): + self.sampling_offsets.bias = nn.Parameter(grid_init.view(-1)) + constant_(self.attention_weights.weight.data, 0.) + constant_(self.attention_weights.bias.data, 0.) + xavier_uniform_(self.value_proj.weight.data) + constant_(self.value_proj.bias.data, 0.) + xavier_uniform_(self.output_proj.weight.data) + constant_(self.output_proj.bias.data, 0.) + + def forward(self, query, reference_points, input_flatten, input_spatial_shapes, input_level_start_index, input_padding_mask=None): + """ + :param query (N, Length_{query}, C) + :param reference_points (N, Length_{query}, n_levels, 2), range in [0, 1], top-left (0,0), bottom-right (1, 1), including padding area + or (N, Length_{query}, n_levels, 4), add additional (w, h) to form reference boxes + :param input_flatten (N, \sum_{l=0}^{L-1} H_l \cdot W_l, C) + :param input_spatial_shapes (n_levels, 2), [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})] + :param input_level_start_index (n_levels, ), [0, H_0*W_0, H_0*W_0+H_1*W_1, H_0*W_0+H_1*W_1+H_2*W_2, ..., H_0*W_0+H_1*W_1+...+H_{L-1}*W_{L-1}] + :param input_padding_mask (N, \sum_{l=0}^{L-1} H_l \cdot W_l), True for padding elements, False for non-padding elements + + :return output (N, Length_{query}, C) + """ + N, Len_q, _ = query.shape + N, Len_in, _ = input_flatten.shape + assert (input_spatial_shapes[:, 0] * input_spatial_shapes[:, 1]).sum() == Len_in + + value = self.value_proj(input_flatten) + if input_padding_mask is not None: + value = value.masked_fill(input_padding_mask[..., None], float(0)) + value = value.view(N, Len_in, self.n_heads, self.d_model // self.n_heads) + sampling_offsets = self.sampling_offsets(query).view(N, Len_q, self.n_heads, self.n_levels, self.n_points, 2) + attention_weights = self.attention_weights(query).view(N, Len_q, self.n_heads, self.n_levels * self.n_points) + attention_weights = F.softmax(attention_weights, -1).view(N, Len_q, self.n_heads, self.n_levels, self.n_points) + # N, Len_q, n_heads, n_levels, n_points, 2 + if reference_points.shape[-1] == 2: + offset_normalizer = torch.stack([input_spatial_shapes[..., 1], input_spatial_shapes[..., 0]], -1) + sampling_locations = reference_points[:, :, None, :, None, :] \ + + sampling_offsets / offset_normalizer[None, None, None, :, None, :] + elif reference_points.shape[-1] == 4: + sampling_locations = reference_points[:, :, None, :, None, :2] \ + + sampling_offsets / self.n_points * reference_points[:, :, None, :, None, 2:] * 0.5 + else: + raise ValueError( + 'Last dim of reference_points must be 2 or 4, but get {} instead.'.format(reference_points.shape[-1])) + try: + output = MSDeformAttnFunction.apply( + value, input_spatial_shapes, input_level_start_index, sampling_locations, attention_weights, self.im2col_step) + except: + # CPU + output = ms_deform_attn_core_pytorch(value, input_spatial_shapes, sampling_locations, attention_weights) + # # For FLOPs calculation only + # output = ms_deform_attn_core_pytorch(value, input_spatial_shapes, sampling_locations, attention_weights) + output = self.output_proj(output) + return output + + +class MSDeformAttnTransformerEncoderOnly(nn.Module): + def __init__( + self, + d_model=256, + nhead=8, + num_encoder_layers=6, + dim_feedforward=1024, + dropout=0.1, + activation="relu", + num_feature_levels=4, + enc_n_points=4, + ): + super().__init__() + + self.d_model = d_model + self.nhead = nhead + + encoder_layer = MSDeformAttnTransformerEncoderLayer( + d_model, + dim_feedforward, + dropout, + activation, + num_feature_levels, + nhead, + enc_n_points, + ) + self.encoder = MSDeformAttnTransformerEncoder(encoder_layer, num_encoder_layers) + + self.level_embed = nn.Parameter(torch.Tensor(num_feature_levels, d_model)) + + self._reset_parameters() + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + for m in self.modules(): + if isinstance(m, MSDeformAttn): + m._reset_parameters() + normal_(self.level_embed) + + def get_valid_ratio(self, mask): + _, H, W = mask.shape + valid_H = torch.sum(~mask[:, :, 0], 1) + valid_W = torch.sum(~mask[:, 0, :], 1) + valid_ratio_h = valid_H.float() / H + valid_ratio_w = valid_W.float() / W + valid_ratio = torch.stack([valid_ratio_w, valid_ratio_h], -1) + return valid_ratio + + def forward(self, srcs, pos_embeds): + masks = [torch.zeros((x.size(0), x.size(2), x.size(3)), device=x.device, dtype=torch.bool) for x in srcs] + # prepare input for encoder + src_flatten = [] + mask_flatten = [] + lvl_pos_embed_flatten = [] + spatial_shapes = [] + for lvl, (src, mask, pos_embed) in enumerate(zip(srcs, masks, pos_embeds)): + bs, c, h, w = src.shape + spatial_shape = (h, w) + spatial_shapes.append(spatial_shape) + src = src.flatten(2).transpose(1, 2) + mask = mask.flatten(1) + pos_embed = pos_embed.flatten(2).transpose(1, 2) + lvl_pos_embed = pos_embed + self.level_embed[lvl].view(1, 1, -1) + lvl_pos_embed_flatten.append(lvl_pos_embed) + src_flatten.append(src) + mask_flatten.append(mask) + src_flatten = torch.cat(src_flatten, 1) + mask_flatten = torch.cat(mask_flatten, 1) + lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1) + spatial_shapes = torch.as_tensor(spatial_shapes, dtype=torch.long, device=src_flatten.device) + level_start_index = torch.cat((spatial_shapes.new_zeros((1, )), spatial_shapes.prod(1).cumsum(0)[:-1])) + valid_ratios = torch.stack([self.get_valid_ratio(m) for m in masks], 1) + + # encoder + memory = self.encoder(src_flatten, spatial_shapes, level_start_index, valid_ratios, lvl_pos_embed_flatten, mask_flatten) + + return memory, spatial_shapes, level_start_index + + +class MSDeformAttnTransformerEncoderLayer(nn.Module): + def __init__( + self, + d_model=256, + d_ffn=1024, + dropout=0.1, + activation="relu", + n_levels=4, + n_heads=8, + n_points=4, + ): + super().__init__() + + # self attention + self.self_attn = MSDeformAttn(d_model, n_levels, n_heads, n_points) + self.dropout1 = nn.Dropout(dropout) + self.norm1 = nn.LayerNorm(d_model) + + # ffn + self.linear1 = nn.Linear(d_model, d_ffn) + self.activation = _get_activation_fn(activation) + self.dropout2 = nn.Dropout(dropout) + self.linear2 = nn.Linear(d_ffn, d_model) + self.dropout3 = nn.Dropout(dropout) + self.norm2 = nn.LayerNorm(d_model) + + @staticmethod + def with_pos_embed(tensor, pos): + return tensor if pos is None else tensor + pos + + def forward_ffn(self, src): + src2 = self.linear2(self.dropout2(self.activation(self.linear1(src)))) + src = src + self.dropout3(src2) + src = self.norm2(src) + return src + + def forward(self, src, pos, reference_points, spatial_shapes, level_start_index, padding_mask=None): + # self attention + src2 = self.self_attn(self.with_pos_embed(src, pos), reference_points, src, spatial_shapes, level_start_index, padding_mask) + src = src + self.dropout1(src2) + src = self.norm1(src) + + # ffn + src = self.forward_ffn(src) + + return src + + +class MSDeformAttnTransformerEncoder(nn.Module): + def __init__(self, encoder_layer, num_layers): + super().__init__() + self.layers = _get_clones(encoder_layer, num_layers) + self.num_layers = num_layers + + @staticmethod + def get_reference_points(spatial_shapes, valid_ratios, device): + reference_points_list = [] + for lvl, (H_, W_) in enumerate(spatial_shapes): + + ref_y, ref_x = torch.meshgrid(torch.linspace(0.5, H_ - 0.5, H_, dtype=torch.float32, device=device), + torch.linspace(0.5, W_ - 0.5, W_, dtype=torch.float32, device=device)) + ref_y = ref_y.reshape(-1)[None] / (valid_ratios[:, None, lvl, 1] * H_) + ref_x = ref_x.reshape(-1)[None] / (valid_ratios[:, None, lvl, 0] * W_) + ref = torch.stack((ref_x, ref_y), -1) + reference_points_list.append(ref) + reference_points = torch.cat(reference_points_list, 1) + reference_points = reference_points[:, :, None] * valid_ratios[:, None] + return reference_points + + def forward(self, src, spatial_shapes, level_start_index, valid_ratios, pos=None, padding_mask=None): + output = src + reference_points = self.get_reference_points(spatial_shapes, valid_ratios, device=src.device) + for _, layer in enumerate(self.layers): + output = layer(output, pos, reference_points, spatial_shapes, level_start_index, padding_mask) + + return output + + +class MSDeformAttnPixelDecoder(nn.Module): + def __init__( + self, + # input_shape: Dict[str, ShapeSpec], + backbone: str = "resnet50", + *, + transformer_dropout: float, + transformer_nheads: int, + transformer_dim_feedforward: int, + transformer_enc_layers: int, + conv_dim: int, + mask_dim: int, + norm: Optional[Union[str, Callable]] = None, + # deformable transformer encoder args + # transformer_in_features: List[str], + common_stride: int, + ): + """ + NOTE: this interface is experimental. + Args: + input_shape: shapes (channels and stride) of the input features + transformer_dropout: dropout probability in transformer + transformer_nheads: number of heads in transformer + transformer_dim_feedforward: dimension of feedforward network + transformer_enc_layers: number of transformer encoder layers + conv_dims: number of output channels for the intermediate conv layers. + mask_dim: number of output channels for the final conv layer. + norm (str or callable): normalization for all conv layers + """ + super().__init__() + + if backbone == "resnet50": + input_shape = { + '0': ShapeSpec(channels=256, height=128, width=128, stride=4), + '1': ShapeSpec(channels=512, height=64, width=64, stride=8), + '2': ShapeSpec(channels=1024, height=32, width=32, stride=16), + '3': ShapeSpec(channels=2048, height=16, width=16, stride=32), + } + transformer_in_features = ['2', '3', '4'] + elif backbone == "efficientnet_b0": + input_shape = { + '0': ShapeSpec(channels=16, height=256, width=256, stride=2), + '1': ShapeSpec(channels=24, height=128, width=128, stride=4), + '2': ShapeSpec(channels=40, height=64, width=64, stride=8), + '3': ShapeSpec(channels=80, height=32, width=32, stride=16), + '4': ShapeSpec(channels=112, height=32, width=32, stride=16), + '5': ShapeSpec(channels=192, height=16, width=16, stride=32), + '6': ShapeSpec(channels=320, height=16, width=16, stride=32), + } + transformer_in_features = ['2', '3', '4', '5', '6'] + elif backbone == "efficientnet_b2": + input_shape = { + '0': ShapeSpec(channels=16, height=256, width=256, stride=2), + '1': ShapeSpec(channels=24, height=128, width=128, stride=4), + '2': ShapeSpec(channels=48, height=64, width=64, stride=8), + '3': ShapeSpec(channels=88, height=32, width=32, stride=16), + '4': ShapeSpec(channels=120, height=32, width=32, stride=16), + '5': ShapeSpec(channels=208, height=16, width=16, stride=32), + '6': ShapeSpec(channels=352, height=16, width=16, stride=32), + } + transformer_in_features = ['2', '3', '4', '5', '6'] + elif backbone == "efficientnet_b4": + input_shape = { + '0': ShapeSpec(channels=24, height=256, width=256, stride=2), + '1': ShapeSpec(channels=32, height=128, width=128, stride=4), + '2': ShapeSpec(channels=56, height=64, width=64, stride=8), + '3': ShapeSpec(channels=112, height=32, width=32, stride=16), + '4': ShapeSpec(channels=160, height=32, width=32, stride=16), + '5': ShapeSpec(channels=272, height=16, width=16, stride=32), + '6': ShapeSpec(channels=448, height=16, width=16, stride=32), + } + transformer_in_features = ['2', '3', '4', '5', '6'] + else: + raise NotImplemented('Please enter a backbone from list: [resnet50, efficientnet_b0, efficientnet_b2, efficientnet_b4]') + + transformer_input_shape = { + k: v for k, v in input_shape.items() if k in transformer_in_features + } + + # this is the input shape of pixel decoder + input_shape = sorted(input_shape.items(), key=lambda x: x[1].stride) + self.in_features = [k for k, v in input_shape] # starting from "res2" to "res5" + self.feature_strides = [v.stride for k, v in input_shape] + self.feature_channels = [v.channels for k, v in input_shape] + + # this is the input shape of transformer encoder (could use less features than pixel decoder + transformer_input_shape = sorted(transformer_input_shape.items(), key=lambda x: x[1].stride) + self.transformer_in_features = [k for k, v in transformer_input_shape] # starting from "res2" to "res5" + transformer_in_channels = [v.channels for k, v in transformer_input_shape] + self.transformer_feature_strides = [v.stride for k, v in transformer_input_shape] # to decide extra FPN layers + + self.transformer_num_feature_levels = len(self.transformer_in_features) + if self.transformer_num_feature_levels > 1: + input_proj_list = [] + # from low resolution to high resolution (res5 -> res2) + for in_channels in transformer_in_channels[::-1]: + input_proj_list.append(nn.Sequential( + nn.Conv2d(in_channels, conv_dim, kernel_size=1), + nn.GroupNorm(32, conv_dim), + )) + self.input_proj = nn.ModuleList(input_proj_list) + else: + self.input_proj = nn.ModuleList([ + nn.Sequential( + nn.Conv2d(transformer_in_channels[-1], conv_dim, kernel_size=1), + nn.GroupNorm(32, conv_dim), + )]) + + for proj in self.input_proj: + nn.init.xavier_uniform_(proj[0].weight, gain=1) + nn.init.constant_(proj[0].bias, 0) + + self.transformer = MSDeformAttnTransformerEncoderOnly( + d_model=conv_dim, + dropout=transformer_dropout, + nhead=transformer_nheads, + dim_feedforward=transformer_dim_feedforward, + num_encoder_layers=transformer_enc_layers, + num_feature_levels=self.transformer_num_feature_levels, + ) + N_steps = conv_dim // 2 + self.pe_layer = PositionEmbeddingSine(N_steps, normalize=True) + + self.mask_dim = mask_dim + # use 1x1 conv instead + self.mask_features = Conv2d( + conv_dim, + mask_dim, + kernel_size=1, + stride=1, + padding=0, + ) + c2_xavier_fill(self.mask_features) + + self.maskformer_num_feature_levels = 3 # always use 3 scales + self.common_stride = common_stride + + # extra fpn levels + stride = min(self.transformer_feature_strides) + self.num_fpn_levels = int(np.log2(stride) - np.log2(self.common_stride)) + + lateral_convs = [] + output_convs = [] + + use_bias = norm == "" + for idx, in_channels in enumerate(self.feature_channels[:self.num_fpn_levels]): + lateral_norm = get_norm(norm, conv_dim) + output_norm = get_norm(norm, conv_dim) + + lateral_conv = Conv2d( + in_channels, conv_dim, kernel_size=1, bias=use_bias, norm=lateral_norm + ) + output_conv = Conv2d( + conv_dim, + conv_dim, + kernel_size=3, + stride=1, + padding=1, + bias=use_bias, + norm=output_norm, + activation=F.relu, + ) + c2_xavier_fill(lateral_conv) + c2_xavier_fill(output_conv) + self.add_module("adapter_{}".format(idx + 1), lateral_conv) + self.add_module("layer_{}".format(idx + 1), output_conv) + + lateral_convs.append(lateral_conv) + output_convs.append(output_conv) + # Place convs into top-down order (from low to high resolution) + # to make the top-down computation in forward clearer. + self.lateral_convs = lateral_convs[::-1] + self.output_convs = output_convs[::-1] + + def forward_features(self, features): + srcs = [] + pos = [] + # Reverse feature maps into top-down order (from low to high resolution) + for idx, f in enumerate(self.transformer_in_features[::-1]): + x = features[f].float() # deformable detr does not support half precision + srcs.append(self.input_proj[idx](x)) + pos.append(self.pe_layer(x)) + + y, spatial_shapes, level_start_index = self.transformer(srcs, pos) + bs = y.shape[0] + + split_size_or_sections = [None] * self.transformer_num_feature_levels + for i in range(self.transformer_num_feature_levels): + if i < self.transformer_num_feature_levels - 1: + split_size_or_sections[i] = level_start_index[i + 1] - level_start_index[i] + else: + split_size_or_sections[i] = y.shape[1] - level_start_index[i] + y = torch.split(y, split_size_or_sections, dim=1) + + out = [] + multi_scale_features = [] + num_cur_levels = 0 + for i, z in enumerate(y): + out.append(z.transpose(1, 2).view(bs, -1, spatial_shapes[i][0], spatial_shapes[i][1])) + + # append `out` with extra FPN levels + # Reverse feature maps into top-down order (from low to high resolution) + for idx, f in enumerate(self.in_features[:self.num_fpn_levels][::-1]): + x = features[f].float() + lateral_conv = self.lateral_convs[idx] + output_conv = self.output_convs[idx] + cur_fpn = lateral_conv(x) + # Following FPN implementation, we use nearest upsampling here + y = cur_fpn + F.interpolate(out[-1], size=cur_fpn.shape[-2:], mode="bilinear", align_corners=False) + y = output_conv(y) + out.append(y) + + for o in out: + if num_cur_levels < self.maskformer_num_feature_levels: + multi_scale_features.append(o) + num_cur_levels += 1 + + return self.mask_features(out[-1]), out[0], multi_scale_features + + +class PositionEmbeddingSine(nn.Module): + """ + This is a more standard version of the position embedding, very similar to the one + used by the Attention is all you need paper, generalized to work on images. + """ + + def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None): + super().__init__() + self.num_pos_feats = num_pos_feats + self.temperature = temperature + self.normalize = normalize + if scale is not None and normalize is False: + raise ValueError("normalize should be True if scale is passed") + if scale is None: + scale = 2 * math.pi + self.scale = scale + + def forward(self, x, mask=None): + if mask is None: + mask = torch.zeros((x.size(0), x.size(2), x.size(3)), device=x.device, dtype=torch.bool) + not_mask = ~mask + y_embed = not_mask.cumsum(1, dtype=torch.float32) + x_embed = not_mask.cumsum(2, dtype=torch.float32) + if self.normalize: + eps = 1e-6 + y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale + x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale + + dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device) + dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats) + + pos_x = x_embed[:, :, :, None] / dim_t + pos_y = y_embed[:, :, :, None] / dim_t + pos_x = torch.stack( + (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4 + ).flatten(3) + pos_y = torch.stack( + (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4 + ).flatten(3) + pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) + return pos + + def __repr__(self, _repr_indent=4): + head = "Positional encoding " + self.__class__.__name__ + body = [ + "num_pos_feats: {}".format(self.num_pos_feats), + "temperature: {}".format(self.temperature), + "normalize: {}".format(self.normalize), + "scale: {}".format(self.scale), + ] + # _repr_indent = 4 + lines = [head] + [" " * _repr_indent + line for line in body] + return "\n".join(lines) + + +def c2_xavier_fill(module: nn.Module) -> None: + """ + Initialize `module.weight` using the "XavierFill" implemented in Caffe2. + Also initializes `module.bias` to 0. + + Args: + module (torch.nn.Module): module to initialize. + """ + # Caffe2 implementation of XavierFill in fact + # corresponds to kaiming_uniform_ in PyTorch + # pyre-fixme[6]: For 1st param expected `Tensor` but got `Union[Module, Tensor]`. + nn.init.kaiming_uniform_(module.weight, a=1) + if module.bias is not None: + # pyre-fixme[6]: Expected `Tensor` for 1st param but got `Union[nn.Module, + # torch.Tensor]`. + nn.init.constant_(module.bias, 0) + + +def get_norm(norm, out_channels): + """ + Args: + norm (str or callable): either one of BN, SyncBN, FrozenBN, GN; + or a callable that takes a channel number and returns + the normalization layer as a nn.Module. + + Returns: + nn.Module or None: the normalization layer + """ + if norm is None: + return None + if isinstance(norm, str): + if len(norm) == 0: + return None + norm = { + "BN": nn.BatchNorm2d, + # Fixed in https://github.com/pytorch/pytorch/pull/36382 + # "SyncBN": NaiveSyncBatchNorm if env.TORCH_VERSION <= (1, 5) else nn.SyncBatchNorm, + # "FrozenBN": FrozenBatchNorm2d, + "GN": lambda channels: nn.GroupNorm(32, channels), + # for debugging: + "nnSyncBN": nn.SyncBatchNorm, + # "naiveSyncBN": NaiveSyncBatchNorm, + # expose stats_mode N as an option to caller, required for zero-len inputs + # "naiveSyncBN_N": lambda channels: NaiveSyncBatchNorm(channels, stats_mode="N"), + "LN": lambda channels: LayerNorm(channels), + }[norm] + return norm(out_channels) + diff --git a/torchsig/models/spectrogram_models/mask2former/predictor.py b/torchsig/models/spectrogram_models/mask2former/predictor.py new file mode 100644 index 0000000..7b22a64 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/predictor.py @@ -0,0 +1,395 @@ +import torch +from torch import nn, Tensor +import torch.nn.functional as F +from typing import Dict, Optional, Union, Callable, List + +from .pixel_decoder import PositionEmbeddingSine, c2_xavier_fill + + +class SelfAttentionLayer(nn.Module): + def __init__(self, d_model, nhead, dropout=0.0, + activation="relu", normalize_before=False): + super().__init__() + self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + + self.norm = nn.LayerNorm(d_model) + self.dropout = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + self._reset_parameters() + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post(self, tgt, + tgt_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + q = k = self.with_pos_embed(tgt, query_pos) + tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask, + key_padding_mask=tgt_key_padding_mask)[0] + tgt = tgt + self.dropout(tgt2) + tgt = self.norm(tgt) + + return tgt + + def forward_pre(self, tgt, + tgt_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + tgt2 = self.norm(tgt) + q = k = self.with_pos_embed(tgt2, query_pos) + tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask, + key_padding_mask=tgt_key_padding_mask)[0] + tgt = tgt + self.dropout(tgt2) + + return tgt + + def forward(self, tgt, + tgt_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + if self.normalize_before: + return self.forward_pre(tgt, tgt_mask, + tgt_key_padding_mask, query_pos) + return self.forward_post(tgt, tgt_mask, + tgt_key_padding_mask, query_pos) + + +class CrossAttentionLayer(nn.Module): + def __init__(self, d_model, nhead, dropout=0.0, + activation="relu", normalize_before=False): + super().__init__() + self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + + self.norm = nn.LayerNorm(d_model) + self.dropout = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + self._reset_parameters() + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post(self, tgt, memory, + memory_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask)[0] + tgt = tgt + self.dropout(tgt2) + tgt = self.norm(tgt) + + return tgt + + def forward_pre(self, tgt, memory, + memory_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + tgt2 = self.norm(tgt) + tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask)[0] + tgt = tgt + self.dropout(tgt2) + + return tgt + + def forward(self, tgt, memory, + memory_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + if self.normalize_before: + return self.forward_pre(tgt, memory, memory_mask, + memory_key_padding_mask, pos, query_pos) + return self.forward_post(tgt, memory, memory_mask, + memory_key_padding_mask, pos, query_pos) + + +class FFNLayer(nn.Module): + def __init__(self, d_model, dim_feedforward=2048, dropout=0.0, + activation="relu", normalize_before=False): + super().__init__() + # Implementation of Feedforward model + self.linear1 = nn.Linear(d_model, dim_feedforward) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + + self.norm = nn.LayerNorm(d_model) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + self._reset_parameters() + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post(self, tgt): + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt)))) + tgt = tgt + self.dropout(tgt2) + tgt = self.norm(tgt) + return tgt + + def forward_pre(self, tgt): + tgt2 = self.norm(tgt) + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2)))) + tgt = tgt + self.dropout(tgt2) + return tgt + + def forward(self, tgt): + if self.normalize_before: + return self.forward_pre(tgt) + return self.forward_post(tgt) + + +def _get_activation_fn(activation): + """Return an activation function given a string""" + if activation == "relu": + return F.relu + if activation == "gelu": + return F.gelu + if activation == "glu": + return F.glu + raise RuntimeError(F"activation should be relu/gelu, not {activation}.") + + +class MLP(nn.Module): + """ Very simple multi-layer perceptron (also called FFN)""" + + def __init__(self, input_dim, hidden_dim, output_dim, num_layers): + super().__init__() + self.num_layers = num_layers + h = [hidden_dim] * (num_layers - 1) + self.layers = nn.ModuleList(nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim])) + + def forward(self, x): + for i, layer in enumerate(self.layers): + x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x) + return x + + +class MultiScaleMaskedTransformerDecoder(nn.Module): + def __init__( + self, + in_channels, + mask_classification=True, + *, + num_classes: int, + hidden_dim: int, + num_queries: int, + nheads: int, + dim_feedforward: int, + dec_layers: int, + pre_norm: bool, + mask_dim: int, + enforce_input_project: bool, + ): + """ + NOTE: this interface is experimental. + Args: + in_channels: channels of the input features + mask_classification: whether to add mask classifier or not + num_classes: number of classes + hidden_dim: Transformer feature dimension + num_queries: number of queries + nheads: number of heads + dim_feedforward: feature dimension in feedforward network + enc_layers: number of Transformer encoder layers + dec_layers: number of Transformer decoder layers + pre_norm: whether to use pre-LayerNorm or not + mask_dim: mask feature dimension + enforce_input_project: add input project 1x1 conv even if input + channels and hidden dim is identical + """ + super().__init__() + + assert mask_classification, "Only support mask classification model" + self.mask_classification = mask_classification + + # positional encoding + N_steps = hidden_dim // 2 + self.pe_layer = PositionEmbeddingSine(N_steps, normalize=True) + + # define Transformer decoder here + self.num_heads = nheads + self.num_layers = dec_layers + self.transformer_self_attention_layers = nn.ModuleList() + self.transformer_cross_attention_layers = nn.ModuleList() + self.transformer_ffn_layers = nn.ModuleList() + + for _ in range(self.num_layers): + self.transformer_self_attention_layers.append( + SelfAttentionLayer( + d_model=hidden_dim, + nhead=nheads, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + + self.transformer_cross_attention_layers.append( + CrossAttentionLayer( + d_model=hidden_dim, + nhead=nheads, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + + self.transformer_ffn_layers.append( + FFNLayer( + d_model=hidden_dim, + dim_feedforward=dim_feedforward, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + + self.decoder_norm = nn.LayerNorm(hidden_dim) + + self.num_queries = num_queries + # learnable query features + self.query_feat = nn.Embedding(num_queries, hidden_dim) + # learnable query p.e. + self.query_embed = nn.Embedding(num_queries, hidden_dim) + + # level embedding (we always use 3 scales) + self.num_feature_levels = 3 + self.level_embed = nn.Embedding(self.num_feature_levels, hidden_dim) + self.input_proj = nn.ModuleList() + for _ in range(self.num_feature_levels): + if in_channels != hidden_dim or enforce_input_project: + self.input_proj.append(nn.Conv2d(in_channels, hidden_dim, kernel_size=1)) + c2_xavier_fill(self.input_proj[-1]) + else: + self.input_proj.append(nn.Sequential()) + + # output FFNs + if self.mask_classification: + self.class_embed = nn.Linear(hidden_dim, num_classes + 1) + self.mask_embed = MLP(hidden_dim, hidden_dim, mask_dim, 3) + + def forward(self, x, mask_features, mask = None): + # x is a list of multi-scale feature + assert len(x) == self.num_feature_levels + src = [] + pos = [] + size_list = [] + + # disable mask, it does not affect performance + del mask + + for i in range(self.num_feature_levels): + size_list.append(x[i].shape[-2:]) + pos.append(self.pe_layer(x[i], None).flatten(2)) + src.append(self.input_proj[i](x[i]).flatten(2) + self.level_embed.weight[i][None, :, None]) + + # flatten NxCxHxW to HWxNxC + pos[-1] = pos[-1].permute(2, 0, 1) + src[-1] = src[-1].permute(2, 0, 1) + + _, bs, _ = src[0].shape + + # QxNxC + query_embed = self.query_embed.weight.unsqueeze(1).repeat(1, bs, 1) + output = self.query_feat.weight.unsqueeze(1).repeat(1, bs, 1) + + predictions_class = [] + predictions_mask = [] + + # prediction heads on learnable query features + outputs_class, outputs_mask, attn_mask = self.forward_prediction_heads(output, mask_features, attn_mask_target_size=size_list[0]) + predictions_class.append(outputs_class) + predictions_mask.append(outputs_mask) + + for i in range(self.num_layers): + level_index = i % self.num_feature_levels + attn_mask[torch.where(attn_mask.sum(-1) == attn_mask.shape[-1])] = False + # attention: cross-attention first + output = self.transformer_cross_attention_layers[i]( + output, src[level_index], + memory_mask=attn_mask, + memory_key_padding_mask=None, # here we do not apply masking on padded region + pos=pos[level_index], query_pos=query_embed + ) + + output = self.transformer_self_attention_layers[i]( + output, tgt_mask=None, + tgt_key_padding_mask=None, + query_pos=query_embed + ) + + # FFN + output = self.transformer_ffn_layers[i]( + output + ) + + outputs_class, outputs_mask, attn_mask = self.forward_prediction_heads(output, mask_features, attn_mask_target_size=size_list[(i + 1) % self.num_feature_levels]) + predictions_class.append(outputs_class) + predictions_mask.append(outputs_mask) + + assert len(predictions_class) == self.num_layers + 1 + + out = { + 'pred_logits': predictions_class[-1], + 'pred_masks': predictions_mask[-1], + 'aux_outputs': self._set_aux_loss( + predictions_class if self.mask_classification else None, predictions_mask + ) + } + return out + + def forward_prediction_heads(self, output, mask_features, attn_mask_target_size): + decoder_output = self.decoder_norm(output) + decoder_output = decoder_output.transpose(0, 1) + outputs_class = self.class_embed(decoder_output) + mask_embed = self.mask_embed(decoder_output) + outputs_mask = torch.einsum("bqc,bchw->bqhw", mask_embed, mask_features) + + # NOTE: prediction is of higher-resolution + # [B, Q, H, W] -> [B, Q, H*W] -> [B, h, Q, H*W] -> [B*h, Q, HW] + attn_mask = F.interpolate(outputs_mask, size=attn_mask_target_size, mode="bilinear", align_corners=False) + # must use bool type + # If a BoolTensor is provided, positions with ``True`` are not allowed to attend while ``False`` values will be unchanged. + attn_mask = (attn_mask.sigmoid().flatten(2).unsqueeze(1).repeat(1, self.num_heads, 1, 1).flatten(0, 1) < 0.5).bool() + attn_mask = attn_mask.detach() + + return outputs_class, outputs_mask, attn_mask + + @torch.jit.unused + def _set_aux_loss(self, outputs_class, outputs_seg_masks): + # this is a workaround to make torchscript happy, as torchscript + # doesn't support dictionary with non-homogeneous values, such + # as a dict having both a Tensor and a list. + if self.mask_classification: + return [ + {"pred_logits": a, "pred_masks": b} + for a, b in zip(outputs_class[:-1], outputs_seg_masks[:-1]) + ] + else: + return [{"pred_masks": b} for b in outputs_seg_masks[:-1]] diff --git a/torchsig/models/spectrogram_models/mask2former/utils.py b/torchsig/models/spectrogram_models/mask2former/utils.py new file mode 100644 index 0000000..7ab3b54 --- /dev/null +++ b/torchsig/models/spectrogram_models/mask2former/utils.py @@ -0,0 +1,298 @@ +import math +import numpy as np +import sympy +import timm +import torch +from torch import nn +from torch import Tensor +import torch.distributed as dist +from torch.optim.lr_scheduler import LambdaLR +import torchvision +from torchvision.ops.boxes import box_area +from torchvision.ops import masks_to_boxes +from typing import List, Optional + + +def drop_classifier(parent): + return torch.nn.Sequential(*list(parent.children())[:-2]) + + +def find_output_features(parent, num_features=0): + for n, m in parent.named_children(): + if type(m) is torch.nn.Conv2d: + num_features = m.out_channels + else: + num_features = find_output_features(m, num_features) + return num_features + + +# Several functions below pulled from public DETR repo: https://github.com/facebookresearch/detr +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + + +def get_world_size(): + if not is_dist_avail_and_initialized(): + return 1 + return dist.get_world_size() + + +@torch.no_grad() +def accuracy(output, target, topk=(1,)): + """Computes the precision@k for the specified values of k""" + if target.numel() == 0: + return [torch.zeros([], device=output.device)] + maxk = max(topk) + batch_size = target.size(0) + + _, pred = output.topk(maxk, 1, True, True) + pred = pred.t() + correct = pred.eq(target.view(1, -1).expand_as(pred)) + + res = [] + for k in topk: + correct_k = correct[:k].view(-1).float().sum(0) + res.append(correct_k.mul_(100.0 / batch_size)) + return res + + +def collate_fn(batch): + return tuple(zip(*batch)) + + +def _max_by_axis(the_list): + # type: (List[List[int]]) -> List[int] + maxes = the_list[0] + for sublist in the_list[1:]: + for index, item in enumerate(sublist): + maxes[index] = max(maxes[index], item) + return maxes + + +def box_cxcywh_to_xyxy(x): + x_c, y_c, w, h = x.unbind(-1) + b = [(x_c - 0.5 * w), (y_c - 0.5 * h), + (x_c + 0.5 * w), (y_c + 0.5 * h)] + return torch.stack(b, dim=-1) + + +# modified from torchvision to also return the union +def box_iou(boxes1, boxes2): + area1 = box_area(boxes1) + area2 = box_area(boxes2) + + lt = torch.max(boxes1[:, None, :2], boxes2[:, :2]) # [N,M,2] + rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) # [N,M,2] + + wh = (rb - lt).clamp(min=0) # [N,M,2] + inter = wh[:, :, 0] * wh[:, :, 1] # [N,M] + + union = area1[:, None] + area2 - inter + + iou = inter / union + return iou, union + + +def generalized_box_iou(boxes1, boxes2): + """ + Generalized IoU from https://giou.stanford.edu/ + The boxes should be in [x0, y0, x1, y1] format + Returns a [N, M] pairwise matrix, where N = len(boxes1) + and M = len(boxes2) + """ + # degenerate boxes gives inf / nan results + # so do an early check + assert (boxes1[:, 2:] >= boxes1[:, :2]).all() + assert (boxes2[:, 2:] >= boxes2[:, :2]).all() + iou, union = box_iou(boxes1, boxes2) + + lt = torch.min(boxes1[:, None, :2], boxes2[:, :2]) + rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:]) + + wh = (rb - lt).clamp(min=0) # [N,M,2] + area = wh[:, :, 0] * wh[:, :, 1] + + return iou - (area - union) / area + + +def calc_area(box): + return max(0,(box[1] - box[0])) * max(0,(box[3] - box[2])) + + +def calc_iou(box1, box2): + area1 = calc_area(box1) + area2 = calc_area(box2) + inter_x1 = max(box1[0], box2[0]) + inter_x2 = min(box1[1], box2[1]) + inter_y1 = max(box1[2], box2[2]) + inter_y2 = min(box1[3], box2[3]) + inter_area = max(0,calc_area([inter_x1, inter_x2, inter_y1, inter_y2])) + union = area1 + area2 - inter_area + iou = inter_area / union + return iou + + +def non_max_suppression_df(detected_signals_df, iou_threshold=0.75): + valid_indices = list(detected_signals_df.index) + remove_indices = [] + for det_idx in valid_indices: + for det_jdx in valid_indices: + if det_idx >= det_jdx: + continue + + # Check if same class + sig1_class = detected_signals_df.loc[det_idx]['Class'] + sig2_class = detected_signals_df.loc[det_jdx]['Class'] + + if sig1_class != sig2_class: + continue + + # convert df to box lists: (x1,x2,y1,y2) + sig1 = [ + detected_signals_df.loc[det_idx]['CenterTimePixel']-detected_signals_df.loc[det_idx]['DurationPixel']/2, + detected_signals_df.loc[det_idx]['CenterTimePixel']+detected_signals_df.loc[det_idx]['DurationPixel']/2, + detected_signals_df.loc[det_idx]['CenterFreqPixel']-detected_signals_df.loc[det_idx]['BandwidthPixel']/2, + detected_signals_df.loc[det_idx]['CenterFreqPixel']+detected_signals_df.loc[det_idx]['BandwidthPixel']/2 + ] + sig2 = [ + detected_signals_df.loc[det_jdx]['CenterTimePixel']-detected_signals_df.loc[det_jdx]['DurationPixel']/2, + detected_signals_df.loc[det_jdx]['CenterTimePixel']+detected_signals_df.loc[det_jdx]['DurationPixel']/2, + detected_signals_df.loc[det_jdx]['CenterFreqPixel']-detected_signals_df.loc[det_jdx]['BandwidthPixel']/2, + detected_signals_df.loc[det_jdx]['CenterFreqPixel']+detected_signals_df.loc[det_jdx]['BandwidthPixel']/2 + ] + + iou_score = calc_iou(sig1, sig2) + + if iou_score > iou_threshold: + # Probably the same signal, take higher confidence signal + sig1_prob = detected_signals_df.loc[det_idx]['Probability'] + sig2_prob = detected_signals_df.loc[det_jdx]['Probability'] + dup_idx = det_idx if sig1_prob < sig2_prob else det_jdx + + # remove from valid_indices + if dup_idx in valid_indices and dup_idx not in remove_indices: + remove_indices.append(dup_idx) + + remove_indices = sorted(remove_indices) + for idx in range(len(remove_indices)-1,-1,-1): + valid_indices.remove(remove_indices[idx]) + + detected_signals_df = detected_signals_df.loc[valid_indices].reset_index(drop=True) + detected_signals_df['DetectionIdx'] = detected_signals_df.index + return detected_signals_df + + +def get_cosine_schedule_with_warmup( + optimizer, + num_warmup_steps, + num_wait_steps, + num_training_steps, + num_cycles=0.5, + last_epoch=-1, +): + def lr_lambda(current_step): + if current_step < num_wait_steps: + return 0.0 + if current_step < num_warmup_steps + num_wait_steps: + return float(current_step - num_wait_steps) / max( + 1, float(num_warmup_steps) + ) + progress = float(current_step - (num_warmup_steps + num_wait_steps)) / float( + max(1, num_training_steps - (num_warmup_steps + num_wait_steps)) + ) + return max( + 0.0, 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress)) + ) + + return LambdaLR(optimizer, lr_lambda, last_epoch) + + +def add_weight_decay(model): + decay = [] + no_decay = [] + for name, param in model.named_parameters(): + if not param.requires_grad: + continue + if "bn" in name: + no_decay.append(param) + else: + decay.append(param) + return [{"params": no_decay, "weight_decay": 0.0}, {"params": decay}] + + +def format_preds(preds): + map_preds = [] + for (i, (det_logits, det_masks)) in enumerate(zip(preds['pred_logits'], preds['pred_masks'])): + boxes = [] + scores = [] + labels = [] + + # Convert Mask2Former output format to expected bboxes + num_objs = 0 + pred = {} + pred['pred_logits'] = det_logits + pred['pred_masks'] = det_masks + + det_list = [] + for obj_idx in range(pred['pred_logits'].shape[0]): + probs = pred['pred_logits'][obj_idx].softmax(-1) + max_prob = probs.max().cpu().detach().numpy() + max_class = probs.argmax().cpu().detach().numpy() + if max_class != (pred['pred_logits'].shape[1] - 1) and max_prob >= 0.5: + mask = torch.sigmoid(pred['pred_masks'][obj_idx]) + mask[mask > 0.5] = 1.0 + mask[mask != 1.0] = 0.0 + if mask.sum() > 0.0: + x1y1x2y2 = masks_to_boxes(mask.unsqueeze(0)).cpu().numpy()[0] + x1y1x2y2 = x1y1x2y2 / (pred['pred_masks'].shape[-1]-1) * 511 # Upscale + x1 = x1y1x2y2[0] + y1 = x1y1x2y2[1] + x2 = x1y1x2y2[2] + y2 = x1y1x2y2[3] + + boxes.append([x1, y1, x2, y2]) + scores.extend([float(max_prob)]) + labels.extend([int(max_class)]) + + curr_pred = dict( + boxes=torch.tensor(boxes).to("cuda"), + scores=torch.tensor(scores).to("cuda"), + labels=torch.IntTensor(labels).to("cuda"), + ) + + map_preds.append(curr_pred) + + return map_preds + + +def format_targets(labels): + map_targets = [] + + for i, label in enumerate(labels): + boxes = [] + scores = [] + labels = [] + + for label_obj_idx in range(len(label['labels'])): + mask = label['masks'][label_obj_idx] + if mask.sum() > 0.0: + x1y1x2y2 = masks_to_boxes(mask.unsqueeze(0)).numpy()[0] + x1 = x1y1x2y2[0] + y1 = x1y1x2y2[1] + x2 = x1y1x2y2[2] + y2 = x1y1x2y2[3] + + boxes.append([x1, y1, x2, y2]) + labels.extend([int(label['labels'][label_obj_idx])]) + + curr_target = dict( + boxes=torch.tensor(boxes).to("cuda"), + labels=torch.IntTensor(labels).to("cuda"), + ) + map_targets.append(curr_target) + + return map_targets \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/pspnet/LICENSE.md b/torchsig/models/spectrogram_models/pspnet/LICENSE.md new file mode 100644 index 0000000..8f14f4e --- /dev/null +++ b/torchsig/models/spectrogram_models/pspnet/LICENSE.md @@ -0,0 +1,21 @@ +The MIT License + +Copyright (c) 2019, Pavel Yakubovskiy + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/pspnet/README.md b/torchsig/models/spectrogram_models/pspnet/README.md new file mode 100644 index 0000000..ec05c32 --- /dev/null +++ b/torchsig/models/spectrogram_models/pspnet/README.md @@ -0,0 +1,5 @@ +# PSPNet + +The PSPNet code contained here relies on the [segmentation_models_pytorch](https://github.com/qubvel/segmentation_models.pytorch) library. + +The segmentation models pytorch library is licensed under an MIT license. This license is contained within this directory. diff --git a/torchsig/models/spectrogram_models/pspnet/__init__.py b/torchsig/models/spectrogram_models/pspnet/__init__.py new file mode 100644 index 0000000..00f4377 --- /dev/null +++ b/torchsig/models/spectrogram_models/pspnet/__init__.py @@ -0,0 +1 @@ +from .pspnet import * \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/pspnet/modules.py b/torchsig/models/spectrogram_models/pspnet/modules.py new file mode 100644 index 0000000..feedc10 --- /dev/null +++ b/torchsig/models/spectrogram_models/pspnet/modules.py @@ -0,0 +1,54 @@ +import numpy as np +import torch +from torch import nn +import segmentation_models_pytorch as smp + +from .utils import replace_bn + + +class BootstrappedCrossEntropy(nn.Module): + def __init__( + self, K: float = 0.15, criterion: nn.Module = None, momentum: float = 0.99998, + ): + super(BootstrappedCrossEntropy, self).__init__() + assert criterion != None, "you must give a criterion function" + self.criterion = criterion + self.K = K + self.momentum = momentum + + def forward(self, pred, target, step): + B, C, H, W = pred.shape + num = int(self.K * B * H * W * max((self.momentum ** step), self.K)) + loss = self.criterion(pred, target) + loss = loss.view(-1) + tk = torch.argsort(loss, descending=True) + TK = loss[tk[num - 1]] + loss = loss[loss >= TK] + return loss.mean() + + +def create_pspnet( + encoder: str = 'efficientnet-b0', + num_classes: int = 53, +) -> torch.nn.Module: + """ + Function used to build a PSPNet network + + Args: + TODO + + Returns: + torch.nn.Module + """ + # Create PSPNet using the SMP library + # Note that the encoder is instantiated within the PSPNet call + network = smp.PSPNet( + encoder_name=encoder, + in_channels=2, + classes=num_classes, + ) + + # Replace batch norm with group norm + replace_bn(network) + + return network \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/pspnet/pspnet.py b/torchsig/models/spectrogram_models/pspnet/pspnet.py new file mode 100644 index 0000000..47096a4 --- /dev/null +++ b/torchsig/models/spectrogram_models/pspnet/pspnet.py @@ -0,0 +1,281 @@ +import timm +import gdown +import torch +import os.path +import numpy as np +from torch import nn + +from .modules import * +from .utils import * + +__all__ = [ + "pspnet_b0", "pspnet_b2", "pspnet_b4", + "pspnet_b0_mod_family", "pspnet_b2_mod_family", "pspnet_b4_mod_family", +] + +model_urls = { + "pspnet_b0": "1dSxMHzfiiqH8uAbWLhOy4jOmIJCP2M35", + "pspnet_b2": "1VnDPdByVMihn1LMVRsU9-_Ndbzvzybvz", + "pspnet_b4": "13gLlx1sSi5t6njp6NnPsphDBN_yYvOu0", + "pspnet_b0_mod_family": "1I1FF0lek3APmrTHakz7LhmTMNkKSPcxg", + "pspnet_b2_mod_family": "1803E3cGMhi2QMmv-Yh27VgE438iheKyJ", + "pspnet_b4_mod_family": "1T8xVV2AnZIeEWIjXe9MKGK7kxdDfBxKM", +} + + +def pspnet_b0( + pretrained: bool = False, + path: str = "pspnet_b0.pt", + num_classes: int = 1, +): + """Constructs a PSPNet architecture with an EfficientNet-B0 backbone. + PSPNet from `"Pyramid Scene Parsing Network" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + NOTE: num_classes should equal the total number of classes **without** + including the background class. That "class" is automatically included. + + """ + # Create PSPNet-B0 + mdl = create_pspnet( + encoder='efficientnet-b0', + num_classes=1+1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['pspnet_b0'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.segmentation_head[0] = torch.nn.Conv2d( + in_channels=mdl.segmentation_head[0].in_channels, + out_channels=num_classes+1, + kernel_size=mdl.segmentation_head[0].kernel_size, + stride=mdl.segmentation_head[0].stride, + padding=mdl.segmentation_head[0].padding, + ) + return mdl + + +def pspnet_b2( + pretrained: bool = False, + path: str = "pspnet_b2.pt", + num_classes: int = 1, +): + """Constructs a PSPNet architecture with an EfficientNet-B2 backbone. + PSPNet from `"Pyramid Scene Parsing Network" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + NOTE: num_classes should equal the total number of classes **without** + including the background class. That "class" is automatically included. + + """ + # Create PSPNet-B2 + mdl = create_pspnet( + encoder='efficientnet-b2', + num_classes=1+1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['pspnet_b2'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.segmentation_head[0] = torch.nn.Conv2d( + in_channels=mdl.segmentation_head[0].in_channels, + out_channels=num_classes+1, + kernel_size=mdl.segmentation_head[0].kernel_size, + stride=mdl.segmentation_head[0].stride, + padding=mdl.segmentation_head[0].padding, + ) + return mdl + + +def pspnet_b4( + pretrained: bool = False, + path: str = "pspnet_b4.pt", + num_classes: int = 1, +): + """Constructs a PSPNet architecture with an EfficientNet-B4 backbone. + PSPNet from `"Pyramid Scene Parsing Network" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + NOTE: num_classes should equal the total number of classes **without** + including the background class. That "class" is automatically included. + + """ + # Create PSPNet-B4 + mdl = create_pspnet( + encoder='efficientnet-b4', + num_classes=1+1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['pspnet_b4'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.segmentation_head[0] = torch.nn.Conv2d( + in_channels=mdl.segmentation_head[0].in_channels, + out_channels=num_classes+1, + kernel_size=mdl.segmentation_head[0].kernel_size, + stride=mdl.segmentation_head[0].stride, + padding=mdl.segmentation_head[0].padding, + ) + return mdl + + +def pspnet_b0_mod_family( + pretrained: bool = False, + path: str = "pspnet_b0_mod_family.pt", + num_classes: int = 6, +): + """Constructs a PSPNet architecture with an EfficientNet-B0 backbone. + PSPNet from `"Pyramid Scene Parsing Network" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + NOTE: num_classes should equal the total number of classes **without** + including the background class. That "class" is automatically included. + + """ + # Create PSPNet-B0 + mdl = create_pspnet( + encoder='efficientnet-b0', + num_classes=6+1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['pspnet_b0_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.segmentation_head[0] = torch.nn.Conv2d( + in_channels=mdl.segmentation_head[0].in_channels, + out_channels=num_classes+1, + kernel_size=mdl.segmentation_head[0].kernel_size, + stride=mdl.segmentation_head[0].stride, + padding=mdl.segmentation_head[0].padding, + ) + return mdl + + +def pspnet_b2_mod_family( + pretrained: bool = False, + path: str = "pspnet_b2_mod_family.pt", + num_classes: int = 6, +): + """Constructs a PSPNet architecture with an EfficientNet-B2 backbone. + PSPNet from `"Pyramid Scene Parsing Network" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + NOTE: num_classes should equal the total number of classes **without** + including the background class. That "class" is automatically included. + + """ + # Create PSPNet-B2 + mdl = create_pspnet( + encoder='efficientnet-b2', + num_classes=6+1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['pspnet_b2_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.segmentation_head[0] = torch.nn.Conv2d( + in_channels=mdl.segmentation_head[0].in_channels, + out_channels=num_classes+1, + kernel_size=mdl.segmentation_head[0].kernel_size, + stride=mdl.segmentation_head[0].stride, + padding=mdl.segmentation_head[0].padding, + ) + return mdl + + +def pspnet_b4_mod_family( + pretrained: bool = False, + path: str = "pspnet_b4_mod_family.pt", + num_classes: int = 6, +): + """Constructs a PSPNet architecture with an EfficientNet-B4 backbone. + PSPNet from `"Pyramid Scene Parsing Network" `_. + EfficientNet from `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks" `_. + + Args: + pretrained (bool): + If True, returns a model pre-trained on WBSig53 + path (str): + Path to existing model or where to download checkpoint to + num_classes (int): + Number of output classes; if loading checkpoint and + number does not equal 1, final layer will not be loaded from checkpoint + NOTE: num_classes should equal the total number of classes **without** + including the background class. That "class" is automatically included. + + """ + # Create PSPNet-B4 + mdl = create_pspnet( + encoder='efficientnet-b4', + num_classes=6+1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['pspnet_b4_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.segmentation_head[0] = torch.nn.Conv2d( + in_channels=mdl.segmentation_head[0].in_channels, + out_channels=num_classes+1, + kernel_size=mdl.segmentation_head[0].kernel_size, + stride=mdl.segmentation_head[0].stride, + padding=mdl.segmentation_head[0].padding, + ) + return mdl diff --git a/torchsig/models/spectrogram_models/pspnet/utils.py b/torchsig/models/spectrogram_models/pspnet/utils.py new file mode 100644 index 0000000..2c281a9 --- /dev/null +++ b/torchsig/models/spectrogram_models/pspnet/utils.py @@ -0,0 +1,140 @@ +import sympy +import numpy as np +import torch +from torch import nn +from scipy import ndimage + + +def acc(y_hat, y): + y_hat = y_hat.argmax(1) + acc = ((y_hat == y)).float().mean() + return acc + + +def iou(y_hat, y): + y_hat = y_hat.argmax(1) + intersection = ((y_hat == 1) & (y == 1)).sum((1, 2)) + union = ((y_hat == 1) | (y == 1)).sum((1, 2)) + iou = (intersection.float() / union.float()).mean() + return iou + + +def class_iou(y_hat, y): + # print(y_hat.shape) # B, C, H, W + # print(y.shape) # B, H, W + y_hat = y_hat.argmax(1) + # print(y_hat.shape) # B, H, W + num_classes = 6 + iou = 0 + num_present = 0 + for batch_idx in range(y.shape[0]): + for class_idx in range(1, num_classes+1): + if (y == class_idx).float().sum() > 0: + intersection = ((y_hat == class_idx) & (y == class_idx)).sum((1, 2)) + union = ((y_hat == class_idx) | (y == class_idx)).sum((1, 2)) + class_iou = ((intersection.float() + 1e-6) / (union.float() + 1e-6)).mean() + iou += class_iou + num_present += 1 + return iou / num_present + + +def replace_bn(parent): + for n, m in parent.named_children(): + if type(m) is nn.BatchNorm2d: + setattr( + parent, + n, + nn.GroupNorm( + min( + sympy.divisors(m.num_features), + key=lambda x: np.abs(np.sqrt(m.num_features) - x), + ), + m.num_features, + ), + ) + else: + replace_bn(m) + + +def format_preds(preds, num_classes): + map_preds = [] + + # Loop over examples in batch + for pred in preds: + boxes = [] + scores = [] + labels = [] + + # Loop over classes + for class_idx in range(1,num_classes+1): + curr_pred = pred.argmax(0) + curr_indices = (curr_pred == class_idx).cpu().numpy() + curr_pred = np.zeros((preds.shape[-2], preds.shape[-1])) + curr_pred[curr_indices] = 1.0 + if curr_pred.sum() == 0: + continue + + image, num_features = ndimage.label(np.abs(curr_pred)) + objs = ndimage.find_objects(image) + + # # Remove small boxes and append to detected signal object + # min_dur = 2 # min time duration + # min_bw = 2 # min bw + # min_area = 4 + + for i, ob in enumerate(objs): + bw = ob[0].stop - ob[0].start + dur = ob[1].stop - ob[1].start + # if (dur > min_dur) and (bw > min_bw) and (bw*dur > min_area): + center_time = (ob[1].stop + ob[1].start) / 2 + center_freq = ob[0].start + bw/2 + + boxes.append([ob[1].start, ob[0].start, ob[1].stop, ob[0].stop]) + scores.extend([1.0]) + labels.extend([class_idx-1]) + + curr_pred = dict( + boxes=torch.tensor(boxes).to("cuda"), + scores=torch.tensor(scores).to("cuda"), + labels=torch.IntTensor(labels).to("cuda"), + ) + map_preds.append(curr_pred) + + return map_preds + + +def format_targets(targets, num_classes): + map_targets = [] + + # Loop over examples in batch + for target in targets: + boxes = [] + labels = [] + + # Loop over classes + for class_idx in range(1,num_classes+1): + curr_indices = (target == class_idx).cpu().numpy() + curr_target = np.zeros((targets.shape[-2], targets.shape[-1])) + curr_target[curr_indices] = 1.0 + if curr_target.sum() == 0: + continue + + image, num_features = ndimage.label(np.abs(curr_target)) + objs = ndimage.find_objects(image) + + for i, ob in enumerate(objs): + bw = ob[0].stop - ob[0].start + dur = ob[1].stop - ob[1].start + center_time = (ob[1].stop + ob[1].start) / 2 + center_freq = ob[0].start + bw/2 + + boxes.append([ob[1].start, ob[0].start, ob[1].stop, ob[0].stop]) + labels.extend([class_idx-1]) + + curr_target = dict( + boxes=torch.tensor(boxes).to("cuda"), + labels=torch.IntTensor(labels).to("cuda"), + ) + map_targets.append(curr_target) + + return map_targets diff --git a/torchsig/models/spectrogram_models/yolov5/LICENSE.md b/torchsig/models/spectrogram_models/yolov5/LICENSE.md new file mode 100644 index 0000000..9e419e0 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/LICENSE.md @@ -0,0 +1,674 @@ +GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/yolov5/README.md b/torchsig/models/spectrogram_models/yolov5/README.md new file mode 100644 index 0000000..ad9d5a1 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/README.md @@ -0,0 +1,5 @@ +# YOLOv5 + +The YOLOv5 code contained here has been cloned, modified, and supplemented from its original [yolov5 github](https://github.com/ultralytics/yolov5). + +YOLOv5 is licensed under a GPL-3.0 license. This license for YOLOv5 is contained within this directory. diff --git a/torchsig/models/spectrogram_models/yolov5/__init__.py b/torchsig/models/spectrogram_models/yolov5/__init__.py new file mode 100644 index 0000000..a444540 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/__init__.py @@ -0,0 +1 @@ +from .yolov5 import * \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/yolov5/mean_ap.py b/torchsig/models/spectrogram_models/yolov5/mean_ap.py new file mode 100644 index 0000000..f8791c1 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/mean_ap.py @@ -0,0 +1,802 @@ +""" +Code is taken from: https://github.com/PyTorchLightning/metrics/blob/a971c6b456e40728b34494ff9186af20da46cb5b/torchmetrics/detection/mean_ap.py + +Modified slightly to patch bugs with device mismatches between cpu and cuda + +""" +# Copyright The PyTorch Lightning team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import logging +from typing import Any, Dict, List, Optional, Sequence, Tuple + +import torch +from torch import IntTensor, Tensor + +from torchmetrics.metric import Metric +from torchmetrics.utilities.imports import _TORCHVISION_GREATER_EQUAL_0_8 + +if _TORCHVISION_GREATER_EQUAL_0_8: + from torchvision.ops import box_area, box_convert, box_iou +else: + box_convert = box_iou = box_area = None + __doctest_skip__ = ["MeanAveragePrecision"] + +log = logging.getLogger(__name__) + + +class BaseMetricResults(dict): + """Base metric class, that allows fields for pre-defined metrics.""" + + def __getattr__(self, key: str) -> Tensor: + # Using this you get the correct error message, an AttributeError instead of a KeyError + if key in self: + return self[key] + raise AttributeError(f"No such attribute: {key}") + + def __setattr__(self, key: str, value: Tensor) -> None: + self[key] = value + + def __delattr__(self, key: str) -> None: + if key in self: + del self[key] + raise AttributeError(f"No such attribute: {key}") + + +class MAPMetricResults(BaseMetricResults): + """Class to wrap the final mAP results.""" + + __slots__ = ("map", "map_50", "map_75", "map_small", "map_medium", "map_large") + + +class MARMetricResults(BaseMetricResults): + """Class to wrap the final mAR results.""" + + __slots__ = ("mar_1", "mar_10", "mar_100", "mar_small", "mar_medium", "mar_large") + + +class COCOMetricResults(BaseMetricResults): + """Class to wrap the final COCO metric results including various mAP/mAR values.""" + + __slots__ = ( + "map", + "map_50", + "map_75", + "map_small", + "map_medium", + "map_large", + "mar_1", + "mar_10", + "mar_100", + "mar_small", + "mar_medium", + "mar_large", + "map_per_class", + "mar_100_per_class", + ) + + +def _input_validator(preds: Sequence[Dict[str, Tensor]], targets: Sequence[Dict[str, Tensor]]) -> None: + """Ensure the correct input format of `preds` and `targets`""" + if not isinstance(preds, Sequence): + raise ValueError("Expected argument `preds` to be of type Sequence") + if not isinstance(targets, Sequence): + raise ValueError("Expected argument `target` to be of type Sequence") + if len(preds) != len(targets): + raise ValueError("Expected argument `preds` and `target` to have the same length") + + for k in ["boxes", "scores", "labels"]: + if any(k not in p for p in preds): + raise ValueError(f"Expected all dicts in `preds` to contain the `{k}` key") + + for k in ["boxes", "labels"]: + if any(k not in p for p in targets): + raise ValueError(f"Expected all dicts in `target` to contain the `{k}` key") + + if any(type(pred["boxes"]) is not Tensor for pred in preds): + raise ValueError("Expected all boxes in `preds` to be of type Tensor") + if any(type(pred["scores"]) is not Tensor for pred in preds): + raise ValueError("Expected all scores in `preds` to be of type Tensor") + if any(type(pred["labels"]) is not Tensor for pred in preds): + raise ValueError("Expected all labels in `preds` to be of type Tensor") + if any(type(target["boxes"]) is not Tensor for target in targets): + raise ValueError("Expected all boxes in `target` to be of type Tensor") + if any(type(target["labels"]) is not Tensor for target in targets): + raise ValueError("Expected all labels in `target` to be of type Tensor") + + for i, item in enumerate(targets): + if item["boxes"].size(0) != item["labels"].size(0): + raise ValueError( + f"Input boxes and labels of sample {i} in targets have a" + f" different length (expected {item['boxes'].size(0)} labels, got {item['labels'].size(0)})" + ) + for i, item in enumerate(preds): + if not (item["boxes"].size(0) == item["labels"].size(0) == item["scores"].size(0)): + raise ValueError( + f"Input boxes, labels and scores of sample {i} in predictions have a" + f" different length (expected {item['boxes'].size(0)} labels and scores," + f" got {item['labels'].size(0)} labels and {item['scores'].size(0)})" + ) + + +def _fix_empty_tensors(boxes: Tensor) -> Tensor: + """Empty tensors can cause problems in DDP mode, this methods corrects them.""" + if boxes.numel() == 0 and boxes.ndim == 1: + return boxes.unsqueeze(0) + return boxes + + +class MeanAveragePrecision(Metric): + r""" + Computes the `Mean-Average-Precision (mAP) and Mean-Average-Recall (mAR) + `_ + for object detection predictions. + Optionally, the mAP and mAR values can be calculated per class. + + Predicted boxes and targets have to be in Pascal VOC format + (xmin-top left, ymin-top left, xmax-bottom right, ymax-bottom right). + See the :meth:`update` method for more information about the input format to this metric. + + For an example on how to use this metric check the `torchmetrics examples + `_ + + .. note:: + This metric is following the mAP implementation of + `pycocotools `_, + a standard implementation for the mAP metric for object detection. + + .. note:: + This metric requires you to have `torchvision` version 0.8.0 or newer installed (with corresponding + version 1.7.0 of torch or newer). Please install with ``pip install torchvision`` or + ``pip install torchmetrics[detection]``. + + Args: + box_format: + Input format of given boxes. Supported formats are ``[`xyxy`, `xywh`, `cxcywh`]``. + iou_thresholds: + IoU thresholds for evaluation. If set to ``None`` it corresponds to the stepped range ``[0.5,...,0.95]`` + with step ``0.05``. Else provide a list of floats. + rec_thresholds: + Recall thresholds for evaluation. If set to ``None`` it corresponds to the stepped range ``[0,...,1]`` + with step ``0.01``. Else provide a list of floats. + max_detection_thresholds: + Thresholds on max detections per image. If set to `None` will use thresholds ``[1, 10, 100]``. + Else, please provide a list of ints. + class_metrics: + Option to enable per-class metrics for mAP and mAR_100. Has a performance impact. + kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. + + Example: + >>> import torch + >>> from torchmetrics.detection.mean_ap import MeanAveragePrecision + >>> preds = [ + ... dict( + ... boxes=torch.tensor([[258.0, 41.0, 606.0, 285.0]]), + ... scores=torch.tensor([0.536]), + ... labels=torch.tensor([0]), + ... ) + ... ] + >>> target = [ + ... dict( + ... boxes=torch.tensor([[214.0, 41.0, 562.0, 285.0]]), + ... labels=torch.tensor([0]), + ... ) + ... ] + >>> metric = MeanAveragePrecision() + >>> metric.update(preds, target) + >>> from pprint import pprint + >>> pprint(metric.compute()) + {'map': tensor(0.6000), + 'map_50': tensor(1.), + 'map_75': tensor(1.), + 'map_large': tensor(0.6000), + 'map_medium': tensor(-1.), + 'map_per_class': tensor(-1.), + 'map_small': tensor(-1.), + 'mar_1': tensor(0.6000), + 'mar_10': tensor(0.6000), + 'mar_100': tensor(0.6000), + 'mar_100_per_class': tensor(-1.), + 'mar_large': tensor(0.6000), + 'mar_medium': tensor(-1.), + 'mar_small': tensor(-1.)} + + Raises: + ModuleNotFoundError: + If ``torchvision`` is not installed or version installed is lower than 0.8.0 + ValueError: + If ``class_metrics`` is not a boolean + """ + is_differentiable: bool = False + higher_is_better: Optional[bool] = None + full_state_update: bool = True + + detection_boxes: List[Tensor] + detection_scores: List[Tensor] + detection_labels: List[Tensor] + groundtruth_boxes: List[Tensor] + groundtruth_labels: List[Tensor] + + def __init__( + self, + box_format: str = "xyxy", + iou_thresholds: Optional[List[float]] = None, + rec_thresholds: Optional[List[float]] = None, + max_detection_thresholds: Optional[List[int]] = None, + class_metrics: bool = False, + **kwargs: Dict[str, Any], + ) -> None: # type: ignore + super().__init__(**kwargs) + + if not _TORCHVISION_GREATER_EQUAL_0_8: + raise ModuleNotFoundError( + "`MeanAveragePrecision` metric requires that `torchvision` version 0.8.0 or newer is installed." + " Please install with `pip install torchvision>=0.8` or `pip install torchmetrics[detection]`." + ) + + allowed_box_formats = ("xyxy", "xywh", "cxcywh") + if box_format not in allowed_box_formats: + raise ValueError(f"Expected argument `box_format` to be one of {allowed_box_formats} but got {box_format}") + self.box_format = box_format + self.iou_thresholds = iou_thresholds or torch.linspace(0.5, 0.95, round((0.95 - 0.5) / 0.05) + 1).tolist() + self.rec_thresholds = rec_thresholds or torch.linspace(0.0, 1.00, round(1.00 / 0.01) + 1).tolist() + max_det_thr, _ = torch.sort(IntTensor(max_detection_thresholds or [1, 10, 100])) + self.max_detection_thresholds = max_det_thr.tolist() + self.bbox_area_ranges = { + "all": (0**2, int(1e5**2)), + "small": (0**2, 32**2), + "medium": (32**2, 96**2), + "large": (96**2, int(1e5**2)), + } + + if not isinstance(class_metrics, bool): + raise ValueError("Expected argument `class_metrics` to be a boolean") + + self.class_metrics = class_metrics + self.add_state("detection_boxes", default=[], dist_reduce_fx=None) + self.add_state("detection_scores", default=[], dist_reduce_fx=None) + self.add_state("detection_labels", default=[], dist_reduce_fx=None) + self.add_state("groundtruth_boxes", default=[], dist_reduce_fx=None) + self.add_state("groundtruth_labels", default=[], dist_reduce_fx=None) + + def update(self, preds: List[Dict[str, Tensor]], target: List[Dict[str, Tensor]]) -> None: # type: ignore + """Add detections and ground truth to the metric. + + Args: + preds: A list consisting of dictionaries each containing the key-values + (each dictionary corresponds to a single image): + + - ``boxes``: ``torch.FloatTensor`` of shape ``[num_boxes, 4]`` containing ``num_boxes`` detection boxes + of the format specified in the constructor. By default, this method expects + ``[xmin, ymin, xmax, ymax]`` in absolute image coordinates. + - ``scores``: ``torch.FloatTensor`` of shape ``[num_boxes]`` containing detection scores for the boxes. + - ``labels``: ``torch.IntTensor`` of shape ``[num_boxes]`` containing 0-indexed detection classes + for the boxes. + + target: A list consisting of dictionaries each containing the key-values + (each dictionary corresponds to a single image): + + - ``boxes``: ``torch.FloatTensor`` of shape ``[num_boxes, 4]`` containing ``num_boxes`` + ground truth boxes of the format specified in the constructor. By default, this method expects + ``[xmin, ymin, xmax, ymax]`` in absolute image coordinates. + - ``labels``: ``torch.IntTensor`` of shape ``[num_boxes]`` containing 1-indexed ground truth + classes for the boxes. + + Raises: + ValueError: + If ``preds`` is not of type ``List[Dict[str, Tensor]]`` + ValueError: + If ``target`` is not of type ``List[Dict[str, Tensor]]`` + ValueError: + If ``preds`` and ``target`` are not of the same length + ValueError: + If any of ``preds.boxes``, ``preds.scores`` and ``preds.labels`` are not of the same length + ValueError: + If any of ``target.boxes`` and ``target.labels`` are not of the same length + ValueError: + If any box is not type float and of length 4 + ValueError: + If any class is not type int and of length 1 + ValueError: + If any score is not type float and of length 1 + """ + _input_validator(preds, target) + + for item in preds: + boxes = _fix_empty_tensors(item["boxes"]) + boxes = box_convert(boxes, in_fmt=self.box_format, out_fmt="xyxy") + self.detection_boxes.append(boxes) + self.detection_labels.append(item["labels"]) + self.detection_scores.append(item["scores"]) + + for item in target: + boxes = _fix_empty_tensors(item["boxes"]) + boxes = box_convert(boxes, in_fmt=self.box_format, out_fmt="xyxy") + self.groundtruth_boxes.append(boxes) + self.groundtruth_labels.append(item["labels"]) + + def _get_classes(self) -> List: + """Returns a list of unique classes found in ground truth and detection data.""" + if len(self.detection_labels) > 0 or len(self.groundtruth_labels) > 0: + return torch.cat(self.detection_labels + self.groundtruth_labels).unique().tolist() + return [] + + def _compute_iou(self, idx: int, class_id: int, max_det: int) -> Tensor: + """Computes the Intersection over Union (IoU) for ground truth and detection bounding boxes for the given + image and class. + + Args: + idx: + Image Id, equivalent to the index of supplied samples + class_id: + Class Id of the supplied ground truth and detection labels + max_det: + Maximum number of evaluated detection bounding boxes + """ + gt = self.groundtruth_boxes[idx] + det = self.detection_boxes[idx] + gt_label_mask = self.groundtruth_labels[idx] == class_id + det_label_mask = self.detection_labels[idx] == class_id + if len(gt_label_mask) == 0 or len(det_label_mask) == 0: + return Tensor([]) + gt = gt[gt_label_mask] + det = det[det_label_mask] + if len(gt) == 0 or len(det) == 0: + return Tensor([]) + + # Sort by scores and use only max detections + scores = self.detection_scores[idx] + scores_filtered = scores[self.detection_labels[idx] == class_id] + inds = torch.argsort(scores_filtered, descending=True) + det = det[inds] + if len(det) > max_det: + det = det[:max_det] + + # generalized_box_iou + ious = box_iou(det, gt) + return ious + + def __evaluate_image_gt_no_preds( + self, gt: Tensor, gt_label_mask: Tensor, area_range: Tuple[int, int], nb_iou_thrs: int + ) -> Dict[str, Any]: + """Some GT but no predictions.""" + # GTs + gt = gt[gt_label_mask] + nb_gt = len(gt) + areas = box_area(gt) + ignore_area = (areas < area_range[0]) | (areas > area_range[1]) + gt_ignore, _ = torch.sort(ignore_area.to(torch.uint8)) + gt_ignore = gt_ignore.to(torch.bool) + + # Detections + nb_det = 0 + det_ignore = torch.zeros((nb_iou_thrs, nb_det), dtype=torch.bool, device=self.device) + + return { + "dtMatches": torch.zeros((nb_iou_thrs, nb_det), dtype=torch.bool, device=self.device), + "gtMatches": torch.zeros((nb_iou_thrs, nb_gt), dtype=torch.bool, device=self.device), + "dtScores": torch.zeros(nb_det, dtype=torch.bool, device=self.device), + "gtIgnore": gt_ignore, + "dtIgnore": det_ignore, + } + + def __evaluate_image_preds_no_gt( + self, det: Tensor, idx: int, det_label_mask: Tensor, max_det: int, area_range: Tuple[int, int], nb_iou_thrs: int + ) -> Dict[str, Any]: + """Some predictions but no GT.""" + # GTs + nb_gt = 0 + gt_ignore = torch.zeros(nb_gt, dtype=torch.bool, device=self.device) + + # Detections + det = det[det_label_mask] + scores = self.detection_scores[idx] + scores_filtered = scores[det_label_mask] + scores_sorted, dtind = torch.sort(scores_filtered, descending=True) + det = det[dtind] + if len(det) > max_det: + det = det[:max_det] + nb_det = len(det) + det_areas = box_area(det).to(self.device) + det_ignore_area = (det_areas < area_range[0]) | (det_areas > area_range[1]) + ar = det_ignore_area.reshape((1, nb_det)) + det_ignore = torch.repeat_interleave(ar, nb_iou_thrs, 0) + + return { + "dtMatches": torch.zeros((nb_iou_thrs, nb_det), dtype=torch.bool, device=self.device), + "gtMatches": torch.zeros((nb_iou_thrs, nb_gt), dtype=torch.bool, device=self.device), + "dtScores": scores_sorted, + "gtIgnore": gt_ignore, + "dtIgnore": det_ignore, + } + + def _evaluate_image( + self, idx: int, class_id: int, area_range: Tuple[int, int], max_det: int, ious: dict + ) -> Optional[dict]: + """Perform evaluation for single class and image. + + Args: + idx: + Image Id, equivalent to the index of supplied samples. + class_id: + Class Id of the supplied ground truth and detection labels. + area_range: + List of lower and upper bounding box area threshold. + max_det: + Maximum number of evaluated detection bounding boxes. + ious: + IoU results for image and class. + """ + gt = self.groundtruth_boxes[idx] + det = self.detection_boxes[idx] + gt_label_mask = self.groundtruth_labels[idx] == class_id + det_label_mask = self.detection_labels[idx] == class_id + + # No Gt and No predictions --> ignore image + if len(gt_label_mask) == 0 and len(det_label_mask) == 0: + return None + + nb_iou_thrs = len(self.iou_thresholds) + + # Some GT but no predictions + if len(gt_label_mask) > 0 and len(det_label_mask) == 0: + return self.__evaluate_image_gt_no_preds(gt, gt_label_mask, area_range, nb_iou_thrs) + + # Some predictions but no GT + if len(gt_label_mask) == 0 and len(det_label_mask) >= 0: + return self.__evaluate_image_preds_no_gt(det, idx, det_label_mask, max_det, area_range, nb_iou_thrs) + + gt = gt[gt_label_mask] + det = det[det_label_mask] + if gt.numel() == 0 and det.numel() == 0: + return None + + areas = box_area(gt) + ignore_area = (areas < area_range[0]) | (areas > area_range[1]) + + # sort dt highest score first, sort gt ignore last + ignore_area_sorted, gtind = torch.sort(ignore_area.to(torch.uint8)) + # Convert to uint8 temporarily and back to bool, because "Sort currently does not support bool dtype on CUDA" + ignore_area_sorted = ignore_area_sorted.to(torch.bool) + gt = gt[gtind] + scores = self.detection_scores[idx] + scores_filtered = scores[det_label_mask] + scores_sorted, dtind = torch.sort(scores_filtered, descending=True) + det = det[dtind] + if len(det) > max_det: + det = det[:max_det] + # load computed ious + ious = ious[idx, class_id][:, gtind] if len(ious[idx, class_id]) > 0 else ious[idx, class_id] + + nb_iou_thrs = len(self.iou_thresholds) + nb_gt = len(gt) + nb_det = len(det) + gt_matches = torch.zeros((nb_iou_thrs, nb_gt), dtype=torch.bool, device=gt.device) + det_matches = torch.zeros((nb_iou_thrs, nb_det), dtype=torch.bool, device=gt.device) + gt_ignore = ignore_area_sorted + det_ignore = torch.zeros((nb_iou_thrs, nb_det), dtype=torch.bool, device=gt.device) + + if torch.numel(ious) > 0: + for idx_iou, t in enumerate(self.iou_thresholds): + for idx_det, _ in enumerate(det): + m = MeanAveragePrecision._find_best_gt_match(t, gt_matches, idx_iou, gt_ignore, ious, idx_det) + if m == -1: + continue + det_ignore[idx_iou, idx_det] = gt_ignore[m] + det_matches[idx_iou, idx_det] = 1 + gt_matches[idx_iou, m] = 1 + + # set unmatched detections outside of area range to ignore + det_areas = box_area(det) + det_ignore_area = (det_areas < area_range[0]) | (det_areas > area_range[1]) + ar = det_ignore_area.reshape((1, nb_det)) + det_ignore = torch.logical_or( + det_ignore, torch.logical_and(det_matches == 0, torch.repeat_interleave(ar, nb_iou_thrs, 0)) + ) + return { + "dtMatches": det_matches.to(self.device), + "gtMatches": gt_matches.to(self.device), + "dtScores": scores_sorted.to(self.device), + "gtIgnore": gt_ignore.to(self.device), + "dtIgnore": det_ignore.to(self.device), + } + + @staticmethod + def _find_best_gt_match( + thr: int, gt_matches: Tensor, idx_iou: float, gt_ignore: Tensor, ious: Tensor, idx_det: int + ) -> int: + """Return id of best ground truth match with current detection. + + Args: + thr: + Current threshold value. + gt_matches: + Tensor showing if a ground truth matches for threshold ``t`` exists. + idx_iou: + Id of threshold ``t``. + gt_ignore: + Tensor showing if ground truth should be ignored. + ious: + IoUs for all combinations of detection and ground truth. + idx_det: + Id of current detection. + """ + previously_matched = gt_matches[idx_iou] + # Remove previously matched or ignored gts + remove_mask = previously_matched | gt_ignore + gt_ious = ious[idx_det] * ~remove_mask + match_idx = gt_ious.argmax().item() + if gt_ious[match_idx] > thr: + return match_idx + return -1 + + def _summarize( + self, + results: Dict, + avg_prec: bool = True, + iou_threshold: Optional[float] = None, + area_range: str = "all", + max_dets: int = 100, + ) -> Tensor: + """Perform evaluation for single class and image. + + Args: + results: + Dictionary including precision, recall and scores for all combinations. + avg_prec: + Calculate average precision. Else calculate average recall. + iou_threshold: + IoU threshold. If set to ``None`` it all values are used. Else results are filtered. + area_range: + Bounding box area range key. + max_dets: + Maximum detections. + """ + area_inds = [i for i, k in enumerate(self.bbox_area_ranges.keys()) if k == area_range] + mdet_inds = [i for i, k in enumerate(self.max_detection_thresholds) if k == max_dets] + if avg_prec: + # dimension of precision: [TxRxKxAxM] + prec = results["precision"] + # IoU + if iou_threshold is not None: + thr = self.iou_thresholds.index(iou_threshold) + prec = prec[thr, :, :, area_inds, mdet_inds] + else: + prec = prec[:, :, :, area_inds, mdet_inds] + else: + # dimension of recall: [TxKxAxM] + prec = results["recall"] + if iou_threshold is not None: + thr = self.iou_thresholds.index(iou_threshold) + prec = prec[thr, :, :, area_inds, mdet_inds] + else: + prec = prec[:, :, area_inds, mdet_inds] + + mean_prec = torch.tensor([-1.0]) if len(prec[prec > -1]) == 0 else torch.mean(prec[prec > -1]) + return mean_prec + + def _calculate(self, class_ids: List) -> Tuple[MAPMetricResults, MARMetricResults]: + """Calculate the precision and recall for all supplied classes to calculate mAP/mAR. + + Args: + class_ids: + List of label class Ids. + """ + img_ids = range(len(self.groundtruth_boxes)) + max_detections = self.max_detection_thresholds[-1] + area_ranges = self.bbox_area_ranges.values() + + ious = { + (idx, class_id): self._compute_iou(idx, class_id, max_detections) + for idx in img_ids + for class_id in class_ids + } + + eval_imgs = [ + self._evaluate_image(img_id, class_id, area, max_detections, ious) + for class_id in class_ids + for area in area_ranges + for img_id in img_ids + ] + + nb_iou_thrs = len(self.iou_thresholds) + nb_rec_thrs = len(self.rec_thresholds) + nb_classes = len(class_ids) + nb_bbox_areas = len(self.bbox_area_ranges) + nb_max_det_thrs = len(self.max_detection_thresholds) + nb_imgs = len(img_ids) + precision = -torch.ones((nb_iou_thrs, nb_rec_thrs, nb_classes, nb_bbox_areas, nb_max_det_thrs)) + recall = -torch.ones((nb_iou_thrs, nb_classes, nb_bbox_areas, nb_max_det_thrs)) + scores = -torch.ones((nb_iou_thrs, nb_rec_thrs, nb_classes, nb_bbox_areas, nb_max_det_thrs)) + + # move tensors if necessary + rec_thresholds_tensor = torch.tensor(self.rec_thresholds) + + # retrieve E at each category, area range, and max number of detections + for idx_cls, _ in enumerate(class_ids): + for idx_bbox_area, _ in enumerate(self.bbox_area_ranges): + for idx_max_det_thrs, max_det in enumerate(self.max_detection_thresholds): + recall, precision, scores = MeanAveragePrecision.__calculate_recall_precision_scores( + recall, + precision, + scores, + idx_cls=idx_cls, + idx_bbox_area=idx_bbox_area, + idx_max_det_thrs=idx_max_det_thrs, + eval_imgs=eval_imgs, + rec_thresholds=rec_thresholds_tensor, + max_det=max_det, + nb_imgs=nb_imgs, + nb_bbox_areas=nb_bbox_areas, + ) + + return precision, recall + + def _summarize_results(self, precisions: Tensor, recalls: Tensor) -> Tuple[MAPMetricResults, MARMetricResults]: + """Summarizes the precision and recall values to calculate mAP/mAR. + + Args: + precisions: + Precision values for different thresholds + recalls: + Recall values for different thresholds + """ + results = dict(precision=precisions, recall=recalls) + map_metrics = MAPMetricResults() + map_metrics.map = self._summarize(results, True) + last_max_det_thr = self.max_detection_thresholds[-1] + if 0.5 in self.iou_thresholds: + map_metrics.map_50 = self._summarize(results, True, iou_threshold=0.5, max_dets=last_max_det_thr) + else: + map_metrics.map_50 = torch.tensor([-1]) + if 0.75 in self.iou_thresholds: + map_metrics.map_75 = self._summarize(results, True, iou_threshold=0.75, max_dets=last_max_det_thr) + else: + map_metrics.map_75 = torch.tensor([-1]) + map_metrics.map_small = self._summarize(results, True, area_range="small", max_dets=last_max_det_thr) + map_metrics.map_medium = self._summarize(results, True, area_range="medium", max_dets=last_max_det_thr) + map_metrics.map_large = self._summarize(results, True, area_range="large", max_dets=last_max_det_thr) + + mar_metrics = MARMetricResults() + for max_det in self.max_detection_thresholds: + mar_metrics[f"mar_{max_det}"] = self._summarize(results, False, max_dets=max_det) + mar_metrics.mar_small = self._summarize(results, False, area_range="small", max_dets=last_max_det_thr) + mar_metrics.mar_medium = self._summarize(results, False, area_range="medium", max_dets=last_max_det_thr) + mar_metrics.mar_large = self._summarize(results, False, area_range="large", max_dets=last_max_det_thr) + + return map_metrics, mar_metrics + + @staticmethod + def __calculate_recall_precision_scores( + recall: Tensor, + precision: Tensor, + scores: Tensor, + idx_cls: int, + idx_bbox_area: int, + idx_max_det_thrs: int, + eval_imgs: list, + rec_thresholds: Tensor, + max_det: int, + nb_imgs: int, + nb_bbox_areas: int, + ) -> Tuple[Tensor, Tensor, Tensor]: + nb_rec_thrs = len(rec_thresholds) + idx_cls_pointer = idx_cls * nb_bbox_areas * nb_imgs + idx_bbox_area_pointer = idx_bbox_area * nb_imgs + # Load all image evals for current class_id and area_range + img_eval_cls_bbox = [eval_imgs[idx_cls_pointer + idx_bbox_area_pointer + i] for i in range(nb_imgs)] + img_eval_cls_bbox = [e for e in img_eval_cls_bbox if e is not None] + if not img_eval_cls_bbox: + return recall, precision, scores + # det_scores = torch.cat([e["dtScores"][:max_det].to("cuda") for e in img_eval_cls_bbox]) + det_scores = torch.cat([e["dtScores"][:max_det].to(torch.uint8).to("cuda") for e in img_eval_cls_bbox]) + + # different sorting method generates slightly different results. + # mergesort is used to be consistent as Matlab implementation. + # Sort in PyTorch does not support bool types on CUDA (yet, 1.11.0) + dtype = torch.uint8 if det_scores.is_cuda and det_scores.dtype is torch.bool else det_scores.dtype + # Explicitly cast to uint8 to avoid error for bool inputs on CUDA to argsort + inds = torch.argsort(det_scores.to(dtype), descending=True) + det_scores_sorted = det_scores[inds] + + det_matches = torch.cat([e["dtMatches"][:, :max_det].to("cuda") for e in img_eval_cls_bbox], axis=1)[:, inds] + det_ignore = torch.cat([e["dtIgnore"][:, :max_det].to("cuda") for e in img_eval_cls_bbox], axis=1)[:, inds] + gt_ignore = torch.cat([e["gtIgnore"].to("cuda") for e in img_eval_cls_bbox]) + npig = torch.count_nonzero(gt_ignore == False) # noqa: E712 + if npig == 0: + return recall, precision, scores + tps = torch.logical_and(det_matches, torch.logical_not(det_ignore)) + fps = torch.logical_and(torch.logical_not(det_matches), torch.logical_not(det_ignore)) + + tp_sum = torch.cumsum(tps, axis=1, dtype=torch.float) + fp_sum = torch.cumsum(fps, axis=1, dtype=torch.float) + for idx, (tp, fp) in enumerate(zip(tp_sum, fp_sum)): + nd = len(tp) + rc = tp / npig + pr = tp / (fp + tp + torch.finfo(torch.float64).eps) + prec = torch.zeros((nb_rec_thrs,)) + score = torch.zeros((nb_rec_thrs,)) + + recall[idx, idx_cls, idx_bbox_area, idx_max_det_thrs] = rc[-1] if nd else 0 + + # Remove zigzags for AUC + diff_zero = torch.zeros((1,), device=pr.device) + diff = torch.ones((1,), device=pr.device) + while not torch.all(diff == 0): + diff = torch.clamp(torch.cat((pr[1:] - pr[:-1], diff_zero), 0), min=0) + pr += diff + + inds = torch.searchsorted(rc, rec_thresholds.to(rc.device), right=False) + num_inds = inds.argmax() if inds.max() >= nd else nb_rec_thrs + inds = inds[:num_inds] + prec[:num_inds] = pr[inds] + score[:num_inds] = det_scores_sorted[inds] + precision[idx, :, idx_cls, idx_bbox_area, idx_max_det_thrs] = prec + scores[idx, :, idx_cls, idx_bbox_area, idx_max_det_thrs] = score + + return recall, precision, scores + + def compute(self) -> dict: + """Compute the `Mean-Average-Precision (mAP) and Mean-Average-Recall (mAR)` scores. + + Note: + ``map`` score is calculated with @[ IoU=self.iou_thresholds | area=all | max_dets=max_detection_thresholds ] + + Caution: If the initialization parameters are changed, dictionary keys for mAR can change as well. + The default properties are also accessible via fields and will raise an ``AttributeError`` if not available. + + Returns: + dict containing + + - map: ``torch.Tensor`` + - map_small: ``torch.Tensor`` + - map_medium: ``torch.Tensor`` + - map_large: ``torch.Tensor`` + - mar_1: ``torch.Tensor`` + - mar_10: ``torch.Tensor`` + - mar_100: ``torch.Tensor`` + - mar_small: ``torch.Tensor`` + - mar_medium: ``torch.Tensor`` + - mar_large: ``torch.Tensor`` + - map_50: ``torch.Tensor`` (-1 if 0.5 not in the list of iou thresholds) + - map_75: ``torch.Tensor`` (-1 if 0.75 not in the list of iou thresholds) + - map_per_class: ``torch.Tensor`` (-1 if class metrics are disabled) + - mar_100_per_class: ``torch.Tensor`` (-1 if class metrics are disabled) + """ + classes = self._get_classes() + precisions, recalls = self._calculate(classes) + map_val, mar_val = self._summarize_results(precisions, recalls) + + # if class mode is enabled, evaluate metrics per class + map_per_class_values: Tensor = torch.tensor([-1.0]) + mar_max_dets_per_class_values: Tensor = torch.tensor([-1.0]) + if self.class_metrics: + map_per_class_list = [] + mar_max_dets_per_class_list = [] + + for class_idx, _ in enumerate(classes): + cls_precisions = precisions[:, :, class_idx].unsqueeze(dim=2) + cls_recalls = recalls[:, class_idx].unsqueeze(dim=1) + cls_map, cls_mar = self._summarize_results(cls_precisions, cls_recalls) + map_per_class_list.append(cls_map.map) + mar_max_dets_per_class_list.append(cls_mar[f"mar_{self.max_detection_thresholds[-1]}"]) + + map_per_class_values = torch.tensor(map_per_class_list, dtype=torch.float) + mar_max_dets_per_class_values = torch.tensor(mar_max_dets_per_class_list, dtype=torch.float) + + metrics = COCOMetricResults() + metrics.update(map_val) + metrics.update(mar_val) + metrics.map_per_class = map_per_class_values + metrics[f"mar_{self.max_detection_thresholds[-1]}_per_class"] = mar_max_dets_per_class_values + return metrics \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/yolov5/modules.py b/torchsig/models/spectrogram_models/yolov5/modules.py new file mode 100644 index 0000000..96dd3f6 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/modules.py @@ -0,0 +1,804 @@ +import os +import sys +import math +import yaml +import warnings +import numpy as np +from pathlib import Path +from copy import copy, deepcopy +import torch +from torch import nn +from torch.nn import functional as F + +from .utils import make_divisible, check_anchor_order, initialize_weights, model_info +from .utils import bbox_iou, is_parallel, check_version + +try: + import thop # for FLOPs computation +except ImportError: + thop = None + + +def smooth_BCE(eps=0.1): + # https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441 + # return positive, negative label smoothing BCE targets + return 1.0 - 0.5 * eps, 0.5 * eps + + +class BCEBlurWithLogitsLoss(nn.Module): + # BCEwithLogitLoss() with reduced missing label effects. + def __init__(self, alpha=0.05): + super().__init__() + self.loss_fcn = nn.BCEWithLogitsLoss(reduction='none') # must be nn.BCEWithLogitsLoss() + self.alpha = alpha + + def forward(self, pred, true): + loss = self.loss_fcn(pred, true) + pred = torch.sigmoid(pred) # prob from logits + dx = pred - true # reduce only missing label effects + # dx = (pred - true).abs() # reduce missing label and false label effects + alpha_factor = 1 - torch.exp((dx - 1) / (self.alpha + 1e-4)) + loss *= alpha_factor + return loss.mean() + + +class FocalLoss(nn.Module): + # Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5) + def __init__(self, loss_fcn, gamma=1.5, alpha=0.25): + super().__init__() + self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss() + self.gamma = gamma + self.alpha = alpha + self.reduction = loss_fcn.reduction + self.loss_fcn.reduction = 'none' # required to apply FL to each element + + def forward(self, pred, true): + loss = self.loss_fcn(pred, true) + # p_t = torch.exp(-loss) + # loss *= self.alpha * (1.000001 - p_t) ** self.gamma # non-zero power for gradient stability + + # TF implementation https://github.com/tensorflow/addons/blob/v0.7.1/tensorflow_addons/losses/focal_loss.py + pred_prob = torch.sigmoid(pred) # prob from logits + p_t = true * pred_prob + (1 - true) * (1 - pred_prob) + alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha) + modulating_factor = (1.0 - p_t) ** self.gamma + loss *= alpha_factor * modulating_factor + + if self.reduction == 'mean': + return loss.mean() + elif self.reduction == 'sum': + return loss.sum() + else: # 'none' + return loss + + +class QFocalLoss(nn.Module): + # Wraps Quality focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5) + def __init__(self, loss_fcn, gamma=1.5, alpha=0.25): + super().__init__() + self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss() + self.gamma = gamma + self.alpha = alpha + self.reduction = loss_fcn.reduction + self.loss_fcn.reduction = 'none' # required to apply FL to each element + + def forward(self, pred, true): + loss = self.loss_fcn(pred, true) + + pred_prob = torch.sigmoid(pred) # prob from logits + alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha) + modulating_factor = torch.abs(true - pred_prob) ** self.gamma + loss *= alpha_factor * modulating_factor + + if self.reduction == 'mean': + return loss.mean() + elif self.reduction == 'sum': + return loss.sum() + else: # 'none' + return loss + + +class ComputeLoss: + # Compute losses + def __init__( + self, + model, + autobalance: bool = False, + box: float = 0.05, # box loss gain + cls: float = 0.5, # cls loss gain + obj: float = 1.0, # obj loss gain (scale with pixels) + cls_pw: float = 1.0, # cls BCELoss positive_weight + obj_pw: float = 1.0, # obj BCELoss positive_weight + anchor_t: float = 4.0, # anchor-multiple threshold + label_smoothing: float = 0.0, # label-smoothing epsilon + fl_gamma: float = 0.0, # focal loss gamma (EfficientDet default gamma=1.5) + ): + self.sort_obj_iou = False + device = next(model.parameters()).device # get model device + h = { + "box": box, + "cls": cls, + "obj": obj, + "cls_pw": cls_pw, + "obj_pw": obj_pw, + "anchor_t": anchor_t, + "label_smoothing": label_smoothing, + "fl_gamma": fl_gamma, + } + + # Define criteria + BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['cls_pw']], device=device)) + BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['obj_pw']], device=device)) + + # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3 + self.cp, self.cn = smooth_BCE(eps=h.get('label_smoothing', 0.0)) # positive, negative BCE targets + + # Focal loss + g = h['fl_gamma'] # focal loss gamma + if g > 0: + BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g) + + det = model.module.model[-1] if is_parallel(model) else model.model[-1] # Detect() module + self.balance = {3: [4.0, 1.0, 0.4]}.get(det.nl, [4.0, 1.0, 0.25, 0.06, 0.02]) # P3-P7 + self.ssi = list(det.stride).index(16) if autobalance else 0 # stride 16 index + self.BCEcls = BCEcls + self.BCEobj = BCEobj + self.gr = 1.0 + self.hyp = h + self.autobalance = autobalance + for k in 'na', 'nc', 'nl', 'anchors': + setattr(self, k, getattr(det, k)) + + def __call__(self, p, targets): # predictions, targets, model + device = targets.device + self.BCEcls = self.BCEcls.to(device) + self.BCEobj = self.BCEobj.to(device) + lcls = torch.zeros(1, device=device) + lbox = torch.zeros(1, device=device) + lobj = torch.zeros(1, device=device) + tcls, tbox, indices, anchors = self.build_targets(p, targets) # targets + + # Losses + for i, pi in enumerate(p): # layer index, layer predictions + b, a, gj, gi = indices[i] # image, anchor, gridy, gridx + tobj = torch.zeros_like(pi[..., 0], device=device) # target obj + + n = b.shape[0] # number of targets + if n: + ps = pi[b, a, gj, gi] # prediction subset corresponding to targets + + # Regression + pxy = ps[:, :2].sigmoid() * 2 - 0.5 + pwh = (ps[:, 2:4].sigmoid() * 2) ** 2 * anchors[i] + pbox = torch.cat((pxy, pwh), 1) # predicted box + iou = bbox_iou(pbox.T, tbox[i], x1y1x2y2=False, CIoU=True) # iou(prediction, target) + lbox += (1.0 - iou).mean() # iou loss + + # Objectness + score_iou = iou.detach().clamp(0).type(tobj.dtype) + if self.sort_obj_iou: + sort_id = torch.argsort(score_iou) + b, a, gj, gi, score_iou = b[sort_id], a[sort_id], gj[sort_id], gi[sort_id], score_iou[sort_id] + tobj[b, a, gj, gi] = (1.0 - self.gr) + self.gr * score_iou # iou ratio + + # Classification + if self.nc > 1: # cls loss (only if multiple classes) + t = torch.full_like(ps[:, 5:], self.cn, device=device) # targets + t[range(n), tcls[i]] = self.cp + lcls += self.BCEcls(ps[:, 5:], t) # BCE + + obji = self.BCEobj(pi[..., 4], tobj) + lobj += obji * self.balance[i] # obj loss + if self.autobalance: + self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item() + + if self.autobalance: + self.balance = [x / self.balance[self.ssi] for x in self.balance] + lbox *= self.hyp['box'] + lobj *= self.hyp['obj'] + lcls *= self.hyp['cls'] + bs = tobj.shape[0] # batch size + + return (lbox + lobj + lcls) * bs, torch.cat((lbox, lobj, lcls)).detach() + + def build_targets(self, p, targets): + # Build targets for compute_loss(), input targets(image,class,x,y,w,h) + na, nt = self.na, targets.shape[0] # number of anchors, targets + tcls, tbox, indices, anch = [], [], [], [] + gain = torch.ones(7, device=targets.device) # normalized to gridspace gain + ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt) + targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices + + g = 0.5 # bias + off = torch.tensor([[0, 0], + [1, 0], [0, 1], [-1, 0], [0, -1], # j,k,l,m + # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm + ], device=targets.device).float() * g # offsets + + for i in range(self.nl): + anchors = self.anchors[i].to(targets.device) + gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain + + # Match targets to anchors + t = targets * gain + if nt: + # Matches + r = t[:, :, 4:6] / anchors[:, None] # wh ratio + j = torch.max(r, 1 / r).max(2)[0] < self.hyp['anchor_t'] # compare + # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2)) + t = t[j] # filter + + # Offsets + gxy = t[:, 2:4] # grid xy + gxi = gain[[2, 3]] - gxy # inverse + j, k = ((gxy % 1 < g) & (gxy > 1)).T + l, m = ((gxi % 1 < g) & (gxi > 1)).T + j = torch.stack((torch.ones_like(j), j, k, l, m)) + t = t.repeat((5, 1, 1))[j] + offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j] + else: + t = targets[0] + offsets = 0 + + # Define + b, c = t[:, :2].long().T # image, class + gxy = t[:, 2:4] # grid xy + gwh = t[:, 4:6] # grid wh + gij = (gxy - offsets).long() + gi, gj = gij.T # grid xy indices + + # Append + a = t[:, 6].long() # anchor indices + indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) # image, anchor, grid indices + tbox.append(torch.cat((gxy - gij, gwh), 1)) # box + anch.append(anchors[a]) # anchors + tcls.append(c) # class + + return tcls, tbox, indices, anch + + +class Detect(nn.Module): + stride = None # strides computed during build + onnx_dynamic = False # ONNX export parameter + + def __init__(self, nc=80, anchors=(), ch=(), inplace=True): # detection layer + super().__init__() + self.nc = nc # number of classes + self.no = nc + 5 # number of outputs per anchor + self.nl = len(anchors) # number of detection layers + self.na = len(anchors[0]) // 2 # number of anchors + self.grid = [torch.zeros(1)] * self.nl # init grid + self.anchor_grid = [torch.zeros(1)] * self.nl # init anchor grid + self.register_buffer('anchors', torch.tensor(anchors).float().view(self.nl, -1, 2)) # shape(nl,na,2) + self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch) # output conv + self.inplace = inplace # use in-place ops (e.g. slice assignment) + + def forward(self, x): + z = [] # inference output + for i in range(self.nl): + x[i] = self.m[i](x[i]) # conv + bs, _, ny, nx = x[i].shape # x(bs,255,20,20) to x(bs,3,20,20,85) + x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous() + + if not self.training: # inference + if self.onnx_dynamic or self.grid[i].shape[2:4] != x[i].shape[2:4]: + self.grid[i], self.anchor_grid[i] = self._make_grid(nx, ny, i) + + y = x[i].sigmoid() + if self.inplace: + y[..., 0:2] = (y[..., 0:2] * 2 - 0.5 + self.grid[i]) * self.stride[i] # xy + y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i] # wh + else: # for YOLOv5 on AWS Inferentia https://github.com/ultralytics/yolov5/pull/2953 + xy = (y[..., 0:2] * 2 - 0.5 + self.grid[i]) * self.stride[i] # xy + wh = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i] # wh + y = torch.cat((xy, wh, y[..., 4:]), -1) + z.append(y.view(bs, -1, self.no)) + + return x if self.training else (torch.cat(z, 1), x) + + def _make_grid(self, nx=20, ny=20, i=0): + d = self.anchors[i].device + if check_version(torch.__version__, '1.10.0'): # torch>=1.10.0 meshgrid workaround for torch>=0.7 compatibility + yv, xv = torch.meshgrid([torch.arange(ny, device=d), torch.arange(nx, device=d)], indexing='ij') + else: + yv, xv = torch.meshgrid([torch.arange(ny, device=d), torch.arange(nx, device=d)]) + grid = torch.stack((xv, yv), 2).expand((1, self.na, ny, nx, 2)).float() + anchor_grid = (self.anchors[i].clone() * self.stride[i]) \ + .view((1, self.na, 1, 1, 2)).expand((1, self.na, ny, nx, 2)).float() + return grid, anchor_grid + + +class YOLOModel(nn.Module): + def __init__( + self, + config='yolov5s.yaml', + in_chans=2, + num_classes=None, + anchors=None, + ): + super().__init__() + if isinstance(config, dict): + self.yaml = config # model dict + else: # is *.yaml + import yaml # for torch hub + dir_path = os.path.dirname(os.path.realpath(__file__)) + config = dir_path + "/" + config + self.yaml_file = Path(config).name + with open(config, encoding='ascii', errors='ignore') as f: + self.yaml = yaml.safe_load(f) # model dict + + # Define model + in_chans = self.yaml['ch'] = self.yaml.get('ch', in_chans) # input channels + if num_classes and num_classes != self.yaml['nc']: + self.yaml['nc'] = num_classes # override yaml value + if anchors: + self.yaml['anchors'] = round(anchors) # override yaml value + self.model, self.save = parse_model(deepcopy(self.yaml), ch=[in_chans]) # model, savelist + self.names = [str(i) for i in range(self.yaml['nc'])] # default names + self.inplace = self.yaml.get('inplace', True) + + # Build strides, anchors + m = self.model[-1] # Detect() + if isinstance(m, Detect): + s = 256 # 2x min stride + m.inplace = self.inplace + m.stride = torch.tensor([s / x.shape[-2] for x in self.forward(torch.zeros(1, in_chans, s, s))]) # forward + m.anchors /= m.stride.view(-1, 1, 1) + check_anchor_order(m) + self.stride = m.stride + self._initialize_biases() # only run once + + # Init weights, biases + initialize_weights(self) + self.info() + + def forward(self, x, augment=False, profile=False, visualize=False): + if augment: + return self._forward_augment(x) # augmented inference, None + return self._forward_once(x, profile, visualize) # single-scale inference, train + + def _forward_augment(self, x): + img_size = x.shape[-2:] # height, width + s = [1, 0.83, 0.67] # scales + f = [None, 3, None] # flips (2-ud, 3-lr) + y = [] # outputs + for si, fi in zip(s, f): + xi = scale_img(x.flip(fi) if fi else x, si, gs=int(self.stride.max())) + yi = self._forward_once(xi)[0] # forward + yi = self._descale_pred(yi, fi, si, img_size) + #yi = self.dequant(yi) + y.append(yi) + y = self._clip_augmented(y) # clip augmented tails + + return torch.cat(y, 1), None # augmented inference, train + + def _forward_once(self, x, profile=False, visualize=False): + y, dt = [], [] # outputs + for m in self.model: + if m.f != -1: # if not from previous layer + if isinstance(m.f, int): + x = y[m.f] + else: + # from earlier layers + x = [x if j == -1 else y[j] for j in m.f] + + if profile: + self._profile_one_layer(m, x, dt) + + x = m(x) # run + y.append(x if m.i in self.save else None) # save output + if visualize: + feature_visualization(x, m.type, m.i, save_dir=visualize) + + return x + + def _descale_pred(self, p, flips, scale, img_size): + # de-scale predictions following augmented inference (inverse operation) + if self.inplace: + p[..., :4] /= scale # de-scale + if flips == 2: + p[..., 1] = img_size[0] - p[..., 1] # de-flip ud + elif flips == 3: + p[..., 0] = img_size[1] - p[..., 0] # de-flip lr + else: + x, y, wh = p[..., 0:1] / scale, p[..., 1:2] / scale, p[..., 2:4] / scale # de-scale + if flips == 2: + y = img_size[0] - y # de-flip ud + elif flips == 3: + x = img_size[1] - x # de-flip lr + p = torch.cat((x, y, wh, p[..., 4:]), -1) + return p + + def _clip_augmented(self, y): + # Clip YOLOv5 augmented inference tails + nl = self.model[-1].nl # number of detection layers (P3-P5) + g = sum(4 ** x for x in range(nl)) # grid points + e = 1 # exclude layer count + i = (y[0].shape[1] // g) * sum(4 ** x for x in range(e)) # indices + y[0] = y[0][:, :-i] # large + i = (y[-1].shape[1] // g) * sum(4 ** (nl - 1 - x) for x in range(e)) # indices + y[-1] = y[-1][:, i:] # small + return y + + def _profile_one_layer(self, m, x, dt): + c = isinstance(m, Detect) # is final layer, copy input as inplace fix + o = thop.profile(m, inputs=(x.copy() if c else x,), verbose=False)[0] / 1E9 * 2 if thop else 0 # FLOPs + t = time_sync() + for _ in range(10): + m(x.copy() if c else x) + dt.append((time_sync() - t) * 100) + + def _initialize_biases(self, cf=None): # initialize biases into Detect(), cf is class frequency + # https://arxiv.org/abs/1708.02002 section 3.3 + # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1. + m = self.model[-1] # Detect() module + for mi, s in zip(m.m, m.stride): # from + b = mi.bias.view(m.na, -1) # conv.bias(255) to (3,85) + b.data[:, 4] += math.log(8 / (640 / s) ** 2) # obj (8 objects per 640 image) + b.data[:, 5:] += math.log(0.6 / (m.nc - 0.999999)) if cf is None else torch.log(cf / cf.sum()) # cls + mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True) + + def _print_biases(self): + m = self.model[-1] # Detect() module + for mi in m.m: # from + b = mi.bias.detach().view(m.na, -1).T # conv.bias(255) to (3,85) + + def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers + for m in self.model.modules(): + if isinstance(m, (Conv, DWConv)) and hasattr(m, 'bn'): + m.conv = fuse_conv_and_bn(m.conv, m.bn) # update conv + delattr(m, 'bn') # remove batchnorm + m.forward = m.forward_fuse # update forward + self.info() + return self + + def info(self, verbose=False, img_size=640): # print model information + model_info(self, verbose, img_size) + + def _apply(self, fn): + # Apply to(), cpu(), cuda(), half() to model tensors that are not parameters or registered buffers + self = super()._apply(fn) + m = self.model[-1] # Detect() + if isinstance(m, Detect): + m.stride = fn(m.stride) + m.grid = list(map(fn, m.grid)) + if isinstance(m.anchor_grid, list): + m.anchor_grid = list(map(fn, m.anchor_grid)) + return self + + +def parse_model(d, ch): # model_dict, input_channels(3) + anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple'] + na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors # number of anchors + no = na * (nc + 5) # number of outputs = anchors * (classes + 5) + + layers, save, c2 = [], [], ch[-1] # layers, savelist, ch out + for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']): # from, number, module, args + m = eval(m) if isinstance(m, str) else m # eval strings + for j, a in enumerate(args): + try: + args[j] = eval(a) if isinstance(a, str) else a # eval strings + except NameError: + pass + + n = n_ = max(round(n * gd), 1) if n > 1 else n # depth gain + if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv, + BottleneckCSP, C3, C3TR, C3SPP, C3Ghost]: + c1, c2 = ch[f], args[0] + if c2 != no: # if not output + c2 = make_divisible(c2 * gw, 8) + + args = [c1, c2, *args[1:]] + if m in [BottleneckCSP, C3, C3TR, C3Ghost]: + args.insert(2, n) # number of repeats + n = 1 + elif m is nn.BatchNorm2d: + args = [ch[f]] + elif m is Concat: + c2 = sum(ch[x] for x in f) + elif m is Detect: + args.append([ch[x] for x in f]) + if isinstance(args[1], int): # number of anchors + args[1] = [list(range(args[1] * 2))] * len(f) + elif m is Contract: + c2 = ch[f] * args[0] ** 2 + elif m is Expand: + c2 = ch[f] // args[0] ** 2 + else: + c2 = ch[f] + + m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args) # module + t = str(m)[8:-2].replace('__main__.', '') # module type + np = sum(x.numel() for x in m_.parameters()) # number params + m_.i, m_.f, m_.type, m_.np = i, f, t, np # attach index, 'from' index, type, number params + save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1) # append to savelist + layers.append(m_) + if i == 0: + ch = [] + ch.append(c2) + return nn.Sequential(*layers), sorted(save) + + +def autopad(k, p=None): # kernel, padding + # Pad to 'same' + if p is None: + p = k // 2 if isinstance(k, int) else [x // 2 for x in k] # auto-pad + return p + + +class Conv(nn.Module): + # Standard convolution + def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): # ch_in, ch_out, kernel, stride, padding, groups + super().__init__() + self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False) + self.bn = nn.BatchNorm2d(c2) + self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity()) + + def forward(self, x): + return self.act(self.bn(self.conv(x))) + + def forward_fuse(self, x): + return self.act(self.conv(x)) + + +class DWConv(Conv): + # Depth-wise convolution class + def __init__(self, c1, c2, k=1, s=1, act=True): # ch_in, ch_out, kernel, stride, padding, groups + super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), act=act) + + +class Bottleneck(nn.Module): + # Standard bottleneck + def __init__(self, c1, c2, shortcut=True, g=1, e=0.5): # ch_in, ch_out, shortcut, groups, expansion + super().__init__() + c_ = int(c2 * e) # hidden channels + self.cv1 = Conv(c1, c_, 1, 1) + self.cv2 = Conv(c_, c2, 3, 1, g=g) + self.add = shortcut and c1 == c2 + + def forward(self, x): + return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x)) + + +class BottleneckCSP(nn.Module): + # CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks + def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): # ch_in, ch_out, number, shortcut, groups, expansion + super().__init__() + c_ = int(c2 * e) # hidden channels + self.cv1 = Conv(c1, c_, 1, 1) + self.cv2 = nn.Conv2d(c1, c_, 1, 1, bias=False) + self.cv3 = nn.Conv2d(c_, c_, 1, 1, bias=False) + self.cv4 = Conv(2 * c_, c2, 1, 1) + self.bn = nn.BatchNorm2d(2 * c_) # applied to cat(cv2, cv3) + self.act = nn.SiLU() + self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n))) + + def forward(self, x): + y1 = self.cv3(self.m(self.cv1(x))) + y2 = self.cv2(x) + return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1)))) + + +class C3(nn.Module): + # CSP Bottleneck with 3 convolutions + def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): # ch_in, ch_out, number, shortcut, groups, expansion + super().__init__() + c_ = int(c2 * e) # hidden channels + self.cv1 = Conv(c1, c_, 1, 1) + self.cv2 = Conv(c1, c_, 1, 1) + self.cv3 = Conv(2 * c_, c2, 1) # act=FReLU(c2) + self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n))) + # self.m = nn.Sequential(*[CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)]) + + def forward(self, x): + return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), dim=1)) + + +class C3TR(C3): + # C3 module with TransformerBlock() + def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): + super().__init__(c1, c2, n, shortcut, g, e) + c_ = int(c2 * e) + self.m = TransformerBlock(c_, c_, 4, n) + + +class C3SPP(C3): + # C3 module with SPP() + def __init__(self, c1, c2, k=(5, 9, 13), n=1, shortcut=True, g=1, e=0.5): + super().__init__(c1, c2, n, shortcut, g, e) + c_ = int(c2 * e) + self.m = SPP(c_, c_, k) + + +class C3Ghost(C3): + # C3 module with GhostBottleneck() + def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): + super().__init__(c1, c2, n, shortcut, g, e) + c_ = int(c2 * e) # hidden channels + self.m = nn.Sequential(*(GhostBottleneck(c_, c_) for _ in range(n))) + + +class SPP(nn.Module): + # Spatial Pyramid Pooling (SPP) layer https://arxiv.org/abs/1406.4729 + def __init__(self, c1, c2, k=(5, 9, 13)): + super().__init__() + c_ = c1 // 2 # hidden channels + self.cv1 = Conv(c1, c_, 1, 1) + self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1) + self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k]) + + def forward(self, x): + x = self.cv1(x) + with warnings.catch_warnings(): + warnings.simplefilter('ignore') # suppress torch 1.9.0 max_pool2d() warning + return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1)) + + +class SPPF(nn.Module): + # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher + def __init__(self, c1, c2, k=5): # equivalent to SPP(k=(5, 9, 13)) + super().__init__() + c_ = c1 // 2 # hidden channels + self.cv1 = Conv(c1, c_, 1, 1) + self.cv2 = Conv(c_ * 4, c2, 1, 1) + self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2) + + def forward(self, x): + x = self.cv1(x) + with warnings.catch_warnings(): + warnings.simplefilter('ignore') # suppress torch 1.9.0 max_pool2d() warning + y1 = self.m(x) + y2 = self.m(y1) + return self.cv2(torch.cat([x, y1, y2, self.m(y2)], 1)) + + +class Focus(nn.Module): + # Focus wh information into c-space + def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): # ch_in, ch_out, kernel, stride, padding, groups + super().__init__() + self.conv = Conv(c1 * 4, c2, k, s, p, g, act) + # self.contract = Contract(gain=2) + + def forward(self, x): # x(b,c,w,h) -> y(b,4c,w/2,h/2) + return self.conv(torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], 1)) + # return self.conv(self.contract(x)) + + +class GhostConv(nn.Module): + # Ghost Convolution https://github.com/huawei-noah/ghostnet + def __init__(self, c1, c2, k=1, s=1, g=1, act=True): # ch_in, ch_out, kernel, stride, groups + super().__init__() + c_ = c2 // 2 # hidden channels + self.cv1 = Conv(c1, c_, k, s, None, g, act) + self.cv2 = Conv(c_, c_, 5, 1, None, c_, act) + + def forward(self, x): + y = self.cv1(x) + return torch.cat([y, self.cv2(y)], 1) + + +class GhostBottleneck(nn.Module): + # Ghost Bottleneck https://github.com/huawei-noah/ghostnet + def __init__(self, c1, c2, k=3, s=1): # ch_in, ch_out, kernel, stride + super().__init__() + c_ = c2 // 2 + self.conv = nn.Sequential(GhostConv(c1, c_, 1, 1), # pw + DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(), # dw + GhostConv(c_, c2, 1, 1, act=False)) # pw-linear + self.shortcut = nn.Sequential(DWConv(c1, c1, k, s, act=False), + Conv(c1, c2, 1, 1, act=False)) if s == 2 else nn.Identity() + + def forward(self, x): + return self.conv(x) + self.shortcut(x) + + +class Contract(nn.Module): + # Contract width-height into channels, i.e. x(1,64,80,80) to x(1,256,40,40) + def __init__(self, gain=2): + super().__init__() + self.gain = gain + + def forward(self, x): + b, c, h, w = x.size() # assert (h / s == 0) and (W / s == 0), 'Indivisible gain' + s = self.gain + x = x.view(b, c, h // s, s, w // s, s) # x(1,64,40,2,40,2) + x = x.permute(0, 3, 5, 1, 2, 4).contiguous() # x(1,2,2,64,40,40) + return x.view(b, c * s * s, h // s, w // s) # x(1,256,40,40) + + +class Expand(nn.Module): + # Expand channels into width-height, i.e. x(1,64,80,80) to x(1,16,160,160) + def __init__(self, gain=2): + super().__init__() + self.gain = gain + + def forward(self, x): + b, c, h, w = x.size() # assert C / s ** 2 == 0, 'Indivisible gain' + s = self.gain + x = x.view(b, s, s, c // s ** 2, h, w) # x(1,2,2,16,80,80) + x = x.permute(0, 3, 4, 1, 5, 2).contiguous() # x(1,16,80,2,80,2) + return x.view(b, c // s ** 2, h * s, w * s) # x(1,16,160,160) + + +class Concat(nn.Module): + # Concatenate a list of tensors along dimension + def __init__(self, dimension=1): + super().__init__() + self.d = dimension + + def forward(self, x): + return torch.cat(x, self.d) + + +class CrossConv(nn.Module): + # Cross Convolution Downsample + def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False): + # ch_in, ch_out, kernel, stride, groups, expansion, shortcut + super().__init__() + c_ = int(c2 * e) # hidden channels + self.cv1 = Conv(c1, c_, (1, k), (1, s)) + self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g) + self.add = shortcut and c1 == c2 + + def forward(self, x): + return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x)) + + +class MixConv2d(nn.Module): + # Mixed Depth-wise Conv https://arxiv.org/abs/1907.09595 + def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True): # ch_in, ch_out, kernel, stride, ch_strategy + super().__init__() + n = len(k) # number of convolutions + if equal_ch: # equal c_ per group + i = torch.linspace(0, n - 1E-6, c2).floor() # c2 indices + c_ = [(i == g).sum() for g in range(n)] # intermediate channels + else: # equal weight.numel() per group + b = [c2] + [0] * n + a = np.eye(n + 1, n, k=-1) + a -= np.roll(a, 1, axis=1) + a *= np.array(k) ** 2 + a[0] = 1 + c_ = np.linalg.lstsq(a, b, rcond=None)[0].round() # solve for equal weight indices, ax = b + + self.m = nn.ModuleList( + [nn.Conv2d(c1, int(c_), k, s, k // 2, groups=math.gcd(c1, int(c_)), bias=False) for k, c_ in zip(k, c_)]) + self.bn = nn.BatchNorm2d(c2) + self.act = nn.SiLU() + + def forward(self, x): + return self.act(self.bn(torch.cat([m(x) for m in self.m], 1))) + + +def create_yolov5( + network: str = 'yolov5s', + num_classes: int = 53, +) -> torch.nn.Module: + """ + Function used to build a YOLOv5 network + + Args: + TODO + + Returns: + torch.nn.Module + + """ + if not ( + network == "yolov5f" or \ + network == "yolov5p" or \ + network == "yolov5n" or \ + network == "yolov5s" or \ + network == "yolov5m" or \ + network == "yolov5l" or \ + network == "yolov5x" + ): + raise NotImplemented("YOLO network specified not implemented.") + + # Build full YOLOv5 network + network = YOLOModel( + config="{}.yaml".format(network), + num_classes=num_classes, + in_chans=2, + ) + + return network \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/yolov5/utils.py b/torchsig/models/spectrogram_models/yolov5/utils.py new file mode 100644 index 0000000..1ef5ec0 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/utils.py @@ -0,0 +1,343 @@ +import time +import math +import numpy as np +import pkg_resources as pkg +from typing import List, Optional, Iterable, List, Any +import torch +from torch import nn +from torch import Tensor +import torch.distributed as dist +from torch.optim.lr_scheduler import LambdaLR +import torchvision + + +def prep_targets(targets: List, device: torch.device = 'cuda') -> torch.Tensor: + device = targets[0]['labels'].device + t_targets = [] + for (i, t) in enumerate(targets): + idx = torch.as_tensor([i], device=device).repeat(len(t['labels'])).reshape(-1,1) + t_targets.append( + torch.cat( + (idx, t['labels'].reshape(-1,1), t['boxes']), + dim=-1 + ) + ) + return torch.cat(t_targets) + + +def make_divisible(x, divisor): + # Returns nearest x divisible by divisor + if isinstance(divisor, torch.Tensor): + divisor = int(divisor.max()) # to int + return math.ceil(x / divisor) * divisor + + +def check_anchor_order(m): + # Check anchor order against stride order for YOLOv5 Detect() module m, and correct if necessary + a = m.anchors.prod(-1).view(-1) # anchor area + da = a[-1] - a[0] # delta a + ds = m.stride[-1] - m.stride[0] # delta s + if da.sign() != ds.sign(): # same order + m.anchors[:] = m.anchors.flip(0) + + +def initialize_weights(model): + for m in model.modules(): + t = type(m) + if t is nn.Conv2d: + pass # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + elif t is nn.BatchNorm2d: + m.eps = 1e-3 + m.momentum = 0.03 + elif t in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6, nn.SiLU]: + m.inplace = True + + +def model_info(model, verbose=False, img_size=640): + # Model information. img_size may be int or list, i.e. img_size=640 or img_size=[640, 320] + n_p = sum(x.numel() for x in model.parameters()) # number parameters + n_g = sum(x.numel() for x in model.parameters() if x.requires_grad) # number gradients + if verbose: + print(f"{'layer':>5} {'name':>40} {'gradient':>9} {'parameters':>12} {'shape':>20} {'mu':>10} {'sigma':>10}") + for i, (name, p) in enumerate(model.named_parameters()): + name = name.replace('module_list.', '') + print('%5g %40s %9s %12g %20s %10.3g %10.3g' % + (i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std())) + + try: # FLOPs + from thop import profile + stride = max(int(model.stride.max()), 32) if hasattr(model, 'stride') else 32 + img = torch.zeros((1, model.yaml.get('ch', 3), stride, stride), device=next(model.parameters()).device) # input + flops = profile(deepcopy(model), inputs=(img,), verbose=False)[0] / 1E9 * 2 # stride GFLOPs + img_size = img_size if isinstance(img_size, list) else [img_size, img_size] # expand if int/float + fs = ', %.1f GFLOPs' % (flops * img_size[0] / stride * img_size[1] / stride) # 640x640 GFLOPs + except (ImportError, Exception): + fs = '' + + +def box_iou(box1, box2): + # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py + """ + Return intersection-over-union (Jaccard index) of boxes. + Both sets of boxes are expected to be in (x1, y1, x2, y2) format. + Arguments: + box1 (Tensor[N, 4]) + box2 (Tensor[M, 4]) + Returns: + iou (Tensor[N, M]): the NxM matrix containing the pairwise + IoU values for every element in boxes1 and boxes2 + """ + def box_area(box): + # box = 4xn + return (box[2] - box[0]) * (box[3] - box[1]) + + area1 = box_area(box1.T) + area2 = box_area(box2.T) + + # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2) + inter = (torch.min(box1[:, None, 2:], box2[:, 2:]) - torch.max(box1[:, None, :2], box2[:, :2])).clamp(0).prod(2) + return inter / (area1[:, None] + area2 - inter) # iou = inter / (area1 + area2 - inter) + + +def bbox_iou(box1, box2, x1y1x2y2=True, GIoU=False, DIoU=False, CIoU=False, eps=1e-7): + # Returns the IoU of box1 to box2. box1 is 4, box2 is nx4 + box2 = box2.T + + # Get the coordinates of bounding boxes + if x1y1x2y2: # x1, y1, x2, y2 = box1 + b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3] + b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3] + else: # transform from xywh to xyxy + b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2 + b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2 + b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2 + b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2 + + # Intersection area + inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \ + (torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0) + + # Union Area + w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps + w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps + union = w1 * h1 + w2 * h2 - inter + eps + + iou = inter / union + if CIoU or DIoU or GIoU: + cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1) # convex (smallest enclosing box) width + ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1) # convex height + if CIoU or DIoU: # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1 + c2 = cw ** 2 + ch ** 2 + eps # convex diagonal squared + rho2 = ((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 + + (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4 # center distance squared + if CIoU: # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47 + v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2) + with torch.no_grad(): + alpha = v / (v - iou + (1 + eps)) + return iou - (rho2 / c2 + v * alpha) # CIoU + return iou - rho2 / c2 # DIoU + c_area = cw * ch + eps # convex area + return iou - (c_area - union) / c_area # GIoU https://arxiv.org/pdf/1902.09630.pdf + return iou # IoU + + +def is_parallel(model): + # Returns True if model is of type DP or DDP + return type(model) in (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel) + + +def check_version(current='0.0.0', minimum='0.0.0', name='version ', pinned=False, hard=False, verbose=False): + # Check version vs. required version + current, minimum = (pkg.parse_version(x) for x in (current, minimum)) + result = (current == minimum) if pinned else (current >= minimum) # bool + s = f'{name}{minimum} required by YOLOv5, but {name}{current} is currently installed' # string + if hard: + assert result, s # assert min requirements met + return result + + +def xywhn2xyxy(x, w=640, h=640, padw=0, padh=0): + # Convert nx4 boxes from [x, y, w, h] normalized to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right + y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x) + y[:, 0] = w * (x[:, 0] - x[:, 2] / 2) + padw # top left x + y[:, 1] = h * (x[:, 1] - x[:, 3] / 2) + padh # top left y + y[:, 2] = w * (x[:, 0] + x[:, 2] / 2) + padw # bottom right x + y[:, 3] = h * (x[:, 1] + x[:, 3] / 2) + padh # bottom right y + return y + + +def xywh2xyxy(x): + # Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right + y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x) + y[:, 0] = x[:, 0] - x[:, 2] / 2 # top left x + y[:, 1] = x[:, 1] - x[:, 3] / 2 # top left y + y[:, 2] = x[:, 0] + x[:, 2] / 2 # bottom right x + y[:, 3] = x[:, 1] + x[:, 3] / 2 # bottom right y + return y + + +def non_max_suppression( + prediction, + conf_thres=0.25, + iou_thres=0.45, + classes=None, + agnostic=False, + multi_label=False, + labels=(), + max_det=300, +): + """Runs Non-Maximum Suppression (NMS) on inference results + + Returns: + list of detections, on (n,6) tensor per image [xyxy, conf, cls] + """ + nc = prediction.shape[2] - 5 # number of classes + xc = prediction[..., 4] > conf_thres # candidates + + # Checks + assert 0 <= conf_thres <= 1, f'Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0' + assert 0 <= iou_thres <= 1, f'Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0' + + # Settings + min_wh, max_wh = 2, 7680 # (pixels) minimum and maximum box width and height + max_nms = 30000 # maximum number of boxes into torchvision.ops.nms() + time_limit = 10.0 # seconds to quit after + redundant = True # require redundant detections + multi_label &= nc > 1 # multiple labels per box (adds 0.5ms/img) + merge = False # use merge-NMS + + t = time.time() + output = [torch.zeros((0, 6), device=prediction.device)] * prediction.shape[0] + for xi, x in enumerate(prediction): # image index, image inference + # Apply constraints + # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height + x = x[xc[xi]] # confidence + + # Cat apriori labels if autolabelling + if labels and len(labels[xi]): + l = labels[xi] + v = torch.zeros((len(l), nc + 5), device=x.device) + v[:, :4] = l[:, 1:5] # box + v[:, 4] = 1.0 # conf + v[range(len(l)), l[:, 0].long() + 5] = 1.0 # cls + x = torch.cat((x, v), 0) + + # If none remain process next image + if not x.shape[0]: + continue + + # Compute conf + x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf + + # Box (center x, center y, width, height) to (x1, y1, x2, y2) + box = xywh2xyxy(x[:, :4]) + + # Detections matrix nx6 (xyxy, conf, cls) + if multi_label: + i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T + x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1) + else: # best class only + conf, j = x[:, 5:].max(1, keepdim=True) + x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres] + + # Filter by class + if classes is not None: + x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)] + + # Apply finite constraint + # if not torch.isfinite(x).all(): + # x = x[torch.isfinite(x).all(1)] + + # Check shape + n = x.shape[0] # number of boxes + if not n: # no boxes + continue + elif n > max_nms: # excess boxes + x = x[x[:, 4].argsort(descending=True)[:max_nms]] # sort by confidence + + # Batched NMS + c = x[:, 5:6] * (0 if agnostic else max_wh) # classes + boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores + i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS + if i.shape[0] > max_det: # limit detections + i = i[:max_det] + if merge and (1 < n < 3E3): # Merge NMS (boxes merged using weighted mean) + # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4) + iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix + weights = iou * scores[None] # box weights + x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True) # merged boxes + if redundant: + i = i[iou.sum(1) > 1] # require redundancy + + output[xi] = x[i] + if (time.time() - t) > time_limit: + print(f'WARNING: NMS time limit {time_limit}s exceeded') + break # time limit exceeded + + return output + + +def format_preds(preds, num_classes=1, threshold=0.5): + map_preds = [] + + # Loop over examples in batch + for pred in preds: + boxes = [] + scores = [] + labels = [] + + # Interpret YOLO outputs + pred = torch.unsqueeze(pred, 0) + pred = non_max_suppression(pred, iou_thres=threshold) + pred = torch.cat(pred).cpu().numpy() + + for obj_idx, obj in enumerate(pred): + center_time = (obj[0] + obj[2]) / 2 + center_freq = (obj[1] + obj[3]) / 2 + duration = obj[2] - obj[0] + bandwidth = obj[3] - obj[1] + + boxes.append([max(0,obj[0]), max(0,obj[1]), min(512,obj[2]), min(512,obj[3])]) + scores.extend([obj[4]]) + labels.extend([int(1)]) if num_classes == 1 else labels.extend([int(obj[5])]) + + curr_pred = dict( + boxes=torch.tensor(boxes).to("cuda"), + scores=torch.tensor(scores).to("cuda"), + labels=torch.IntTensor(labels).to("cuda"), + ) + map_preds.append(curr_pred) + + return map_preds + + +def format_targets(labels, num_classes=1): + map_targets = [] + + for i, label in enumerate(labels): + boxes = [] + scores = [] + labels = [] + + for label_obj_idx in range(len(label['labels'])): + center_time = label["boxes"][label_obj_idx][0] + center_freq = label["boxes"][label_obj_idx][1] + duration = label["boxes"][label_obj_idx][2] + bandwidth = label["boxes"][label_obj_idx][3] + class_idx = label["labels"][label_obj_idx] + + x1 = (center_time - duration / 2) * 512 + y1 = (center_freq - bandwidth / 2) * 512 + x2 = (center_time + duration / 2) * 512 + y2 = (center_freq + bandwidth / 2) * 512 + + boxes.append([x1, y1, x2, y2]) + labels.extend([int(1)]) if num_classes == 1 else labels.extend([int(class_idx)]) + + curr_target = dict( + boxes=torch.tensor(boxes).to("cuda"), + labels=torch.IntTensor(labels).to("cuda"), + ) + map_targets.append(curr_target) + + return map_targets \ No newline at end of file diff --git a/torchsig/models/spectrogram_models/yolov5/yolov5.py b/torchsig/models/spectrogram_models/yolov5/yolov5.py new file mode 100644 index 0000000..bd8fbdd --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/yolov5.py @@ -0,0 +1,247 @@ +import timm +import gdown +import torch +import os.path +import numpy as np +from torch import nn + +from .modules import * +from .utils import * +from .mean_ap import * + + +__all__ = [ + "yolov5p", "yolov5n", "yolov5s", + "yolov5p_mod_family", "yolov5n_mod_family", "yolov5s_mod_family", +] + +model_urls = { + "yolov5p": "1d1ihKbtGQciRwqmBDrHiESZ22zx9W01S", + "yolov5n": "184h1f8-DV3FDYd01X7TdKmxWZ2s73FiH", + "yolov5s": "1t7hHB4uXJ0BaSEmq_li2oj1tEDXgZh0z", + "yolov5p_mod_family": "1z8VLEpVqQEFPW3u4T3Yd6c5J0e__UDqf", + "yolov5n_mod_family": "1B2ke51DGbpZXOMhuWTQLXZaDM59VC5Mm", + "yolov5s_mod_family": "1HzcKfM4URtAqhCIQr_obXWWbYIFsEE4s", +} + + +def yolov5p( + pretrained: bool = False, + path: str = "yolov5p.pt", + num_classes: int = 1, +): + """Constructs a YOLOv5 architecture with Pico scaling. + YOLOv5 from `"YOLOv5 GitHub" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + + """ + # Create YOLOv5p + mdl = create_yolov5( + network='yolov5p', + num_classes=1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['yolov5p'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.model[-1].no = int(mdl.model[-1].no / (1 + 5) * (num_classes + 5)) + for det_conv_idx in range(len(mdl.model[-1].m)): + mdl.model[-1].m[det_conv_idx] = torch.nn.Conv2d( + in_channels=mdl.model[-1].m[det_conv_idx].in_channels, + out_channels=int(mdl.model[-1].m[det_conv_idx].out_channels / (1+5) * (num_classes + 5)), + kernel_size=mdl.model[-1].m[det_conv_idx].kernel_size, + stride=mdl.model[-1].m[det_conv_idx].stride, + ) + return mdl + + +def yolov5n( + pretrained: bool = False, + path: str = "yolov5n.pt", + num_classes: int = 1, +): + """Constructs a YOLOv5 architecture with Nano scaling. + YOLOv5 from `"YOLOv5 GitHub" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + + """ + # Create YOLOv5p + mdl = create_yolov5( + network='yolov5n', + num_classes=1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['yolov5n'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.model[-1].no = int(mdl.model[-1].no / (1 + 5) * (num_classes + 5)) + for det_conv_idx in range(len(mdl.model[-1].m)): + mdl.model[-1].m[det_conv_idx] = torch.nn.Conv2d( + in_channels=mdl.model[-1].m[det_conv_idx].in_channels, + out_channels=int(mdl.model[-1].m[det_conv_idx].out_channels / (1+5) * (num_classes + 5)), + kernel_size=mdl.model[-1].m[det_conv_idx].kernel_size, + stride=mdl.model[-1].m[det_conv_idx].stride, + ) + return mdl + + +def yolov5s( + pretrained: bool = False, + path: str = "yolov5s.pt", + num_classes: int = 1, +): + """Constructs a YOLOv5 architecture with Small scaling. + YOLOv5 from `"YOLOv5 GitHub" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + + """ + # Create YOLOv5p + mdl = create_yolov5( + network='yolov5s', + num_classes=1, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['yolov5s'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 1: + mdl.model[-1].no = int(mdl.model[-1].no / (1 + 5) * (num_classes + 5)) + for det_conv_idx in range(len(mdl.model[-1].m)): + mdl.model[-1].m[det_conv_idx] = torch.nn.Conv2d( + in_channels=mdl.model[-1].m[det_conv_idx].in_channels, + out_channels=int(mdl.model[-1].m[det_conv_idx].out_channels / (1+5) * (num_classes + 5)), + kernel_size=mdl.model[-1].m[det_conv_idx].kernel_size, + stride=mdl.model[-1].m[det_conv_idx].stride, + ) + return mdl + + +def yolov5p_mod_family( + pretrained: bool = False, + path: str = "yolov5p.pt", + num_classes: int = 6, +): + """Constructs a YOLOv5 architecture with Pico scaling. + YOLOv5 from `"YOLOv5 GitHub" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + + """ + # Create YOLOv5p + mdl = create_yolov5( + network='yolov5p', + num_classes=6, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['yolov5p_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.model[-1].no = int(mdl.model[-1].no / (6 + 5) * (num_classes + 5)) + for det_conv_idx in range(len(mdl.model[-1].m)): + mdl.model[-1].m[det_conv_idx] = torch.nn.Conv2d( + in_channels=mdl.model[-1].m[det_conv_idx].in_channels, + out_channels=int(mdl.model[-1].m[det_conv_idx].out_channels / (6+5) * (num_classes + 5)), + kernel_size=mdl.model[-1].m[det_conv_idx].kernel_size, + stride=mdl.model[-1].m[det_conv_idx].stride, + ) + return mdl + + +def yolov5n_mod_family( + pretrained: bool = False, + path: str = "yolov5n.pt", + num_classes: int = 6, +): + """Constructs a YOLOv5 architecture with Nano scaling. + YOLOv5 from `"YOLOv5 GitHub" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + + """ + # Create YOLOv5p + mdl = create_yolov5( + network='yolov5n', + num_classes=6, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['yolov5n_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.model[-1].no = int(mdl.model[-1].no / (6 + 5) * (num_classes + 5)) + for det_conv_idx in range(len(mdl.model[-1].m)): + mdl.model[-1].m[det_conv_idx] = torch.nn.Conv2d( + in_channels=mdl.model[-1].m[det_conv_idx].in_channels, + out_channels=int(mdl.model[-1].m[det_conv_idx].out_channels / (6+5) * (num_classes + 5)), + kernel_size=mdl.model[-1].m[det_conv_idx].kernel_size, + stride=mdl.model[-1].m[det_conv_idx].stride, + ) + return mdl + + +def yolov5s_mod_family( + pretrained: bool = False, + path: str = "yolov5s.pt", + num_classes: int = 6, +): + """Constructs a YOLOv5 architecture with Small scaling. + YOLOv5 from `"YOLOv5 GitHub" `_. + + Args: + pretrained (bool): If True, returns a model pre-trained on WBSig53 + path (str): Path to existing model or where to download checkpoint to + num_classes (int): Number of output classes; if loading checkpoint and number does not equal 1, final layer will not be loaded from checkpoint + + """ + # Create YOLOv5p + mdl = create_yolov5( + network='yolov5s', + num_classes=6, + ) + if pretrained: + model_exists = os.path.exists(path) + if not model_exists: + file_id = model_urls['yolov5s_mod_family'] + dl = gdown.download(id=file_id, output=path) + mdl.load_state_dict(torch.load(path), strict=False) + if num_classes != 6: + mdl.model[-1].no = int(mdl.model[-1].no / (6 + 5) * (num_classes + 5)) + for det_conv_idx in range(len(mdl.model[-1].m)): + mdl.model[-1].m[det_conv_idx] = torch.nn.Conv2d( + in_channels=mdl.model[-1].m[det_conv_idx].in_channels, + out_channels=int(mdl.model[-1].m[det_conv_idx].out_channels / (6+5) * (num_classes + 5)), + kernel_size=mdl.model[-1].m[det_conv_idx].kernel_size, + stride=mdl.model[-1].m[det_conv_idx].stride, + ) + return mdl diff --git a/torchsig/models/spectrogram_models/yolov5/yolov5f.yaml b/torchsig/models/spectrogram_models/yolov5/yolov5f.yaml new file mode 100644 index 0000000..9f76f04 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/yolov5f.yaml @@ -0,0 +1,50 @@ +# YOLOv5 🚀 by Ultralytics, GPL-3.0 license + +# Parameters +nc: 80 # number of classes +#depth_multiple: 0.23 # model depth multiple +#width_multiple: 0.1875 # layer channel multiple +depth_multiple: 0.1 +width_multiple: 0.05 +anchors: + - [10,13, 16,30, 33,23] # P3/8 + - [30,61, 62,45, 59,119] # P4/16 + - [116,90, 156,198, 373,326] # P5/32 + +# YOLOv5 v6.0 backbone +backbone: + # [from, number, module, args] + [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 + [-1, 1, Conv, [128, 3, 2]], # 1-P2/4 + [-1, 3, C3, [128]], + [-1, 1, Conv, [256, 3, 2]], # 3-P3/8 + [-1, 6, C3, [256]], + [-1, 1, Conv, [512, 3, 2]], # 5-P4/16 + [-1, 9, C3, [512]], + [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32 + [-1, 3, C3, [1024]], + [-1, 1, SPPF, [1024, 5]], # 9 + ] + +# YOLOv5 v6.0 head +head: + [[-1, 1, Conv, [512, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 6], 1, Concat, [1]], # cat backbone P4 + [-1, 3, C3, [512, False]], # 13 + + [-1, 1, Conv, [256, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 4], 1, Concat, [1]], # cat backbone P3 + [-1, 3, C3, [256, False]], # 17 (P3/8-small) + + [-1, 1, Conv, [256, 3, 2]], + [[-1, 14], 1, Concat, [1]], # cat head P4 + [-1, 3, C3, [512, False]], # 20 (P4/16-medium) + + [-1, 1, Conv, [512, 3, 2]], + [[-1, 10], 1, Concat, [1]], # cat head P5 + [-1, 3, C3, [1024, False]], # 23 (P5/32-large) + + [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5) + ] diff --git a/torchsig/models/spectrogram_models/yolov5/yolov5l.yaml b/torchsig/models/spectrogram_models/yolov5/yolov5l.yaml new file mode 100644 index 0000000..ce8a5de --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/yolov5l.yaml @@ -0,0 +1,48 @@ +# YOLOv5 🚀 by Ultralytics, GPL-3.0 license + +# Parameters +nc: 80 # number of classes +depth_multiple: 1.0 # model depth multiple +width_multiple: 1.0 # layer channel multiple +anchors: + - [10,13, 16,30, 33,23] # P3/8 + - [30,61, 62,45, 59,119] # P4/16 + - [116,90, 156,198, 373,326] # P5/32 + +# YOLOv5 v6.0 backbone +backbone: + # [from, number, module, args] + [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 + [-1, 1, Conv, [128, 3, 2]], # 1-P2/4 + [-1, 3, C3, [128]], + [-1, 1, Conv, [256, 3, 2]], # 3-P3/8 + [-1, 6, C3, [256]], + [-1, 1, Conv, [512, 3, 2]], # 5-P4/16 + [-1, 9, C3, [512]], + [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32 + [-1, 3, C3, [1024]], + [-1, 1, SPPF, [1024, 5]], # 9 + ] + +# YOLOv5 v6.0 head +head: + [[-1, 1, Conv, [512, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 6], 1, Concat, [1]], # cat backbone P4 + [-1, 3, C3, [512, False]], # 13 + + [-1, 1, Conv, [256, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 4], 1, Concat, [1]], # cat backbone P3 + [-1, 3, C3, [256, False]], # 17 (P3/8-small) + + [-1, 1, Conv, [256, 3, 2]], + [[-1, 14], 1, Concat, [1]], # cat head P4 + [-1, 3, C3, [512, False]], # 20 (P4/16-medium) + + [-1, 1, Conv, [512, 3, 2]], + [[-1, 10], 1, Concat, [1]], # cat head P5 + [-1, 3, C3, [1024, False]], # 23 (P5/32-large) + + [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5) + ] diff --git a/torchsig/models/spectrogram_models/yolov5/yolov5m.yaml b/torchsig/models/spectrogram_models/yolov5/yolov5m.yaml new file mode 100644 index 0000000..ad13ab3 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/yolov5m.yaml @@ -0,0 +1,48 @@ +# YOLOv5 🚀 by Ultralytics, GPL-3.0 license + +# Parameters +nc: 80 # number of classes +depth_multiple: 0.67 # model depth multiple +width_multiple: 0.75 # layer channel multiple +anchors: + - [10,13, 16,30, 33,23] # P3/8 + - [30,61, 62,45, 59,119] # P4/16 + - [116,90, 156,198, 373,326] # P5/32 + +# YOLOv5 v6.0 backbone +backbone: + # [from, number, module, args] + [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 + [-1, 1, Conv, [128, 3, 2]], # 1-P2/4 + [-1, 3, C3, [128]], + [-1, 1, Conv, [256, 3, 2]], # 3-P3/8 + [-1, 6, C3, [256]], + [-1, 1, Conv, [512, 3, 2]], # 5-P4/16 + [-1, 9, C3, [512]], + [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32 + [-1, 3, C3, [1024]], + [-1, 1, SPPF, [1024, 5]], # 9 + ] + +# YOLOv5 v6.0 head +head: + [[-1, 1, Conv, [512, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 6], 1, Concat, [1]], # cat backbone P4 + [-1, 3, C3, [512, False]], # 13 + + [-1, 1, Conv, [256, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 4], 1, Concat, [1]], # cat backbone P3 + [-1, 3, C3, [256, False]], # 17 (P3/8-small) + + [-1, 1, Conv, [256, 3, 2]], + [[-1, 14], 1, Concat, [1]], # cat head P4 + [-1, 3, C3, [512, False]], # 20 (P4/16-medium) + + [-1, 1, Conv, [512, 3, 2]], + [[-1, 10], 1, Concat, [1]], # cat head P5 + [-1, 3, C3, [1024, False]], # 23 (P5/32-large) + + [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5) + ] diff --git a/torchsig/models/spectrogram_models/yolov5/yolov5n.yaml b/torchsig/models/spectrogram_models/yolov5/yolov5n.yaml new file mode 100644 index 0000000..8a28a40 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/yolov5n.yaml @@ -0,0 +1,48 @@ +# YOLOv5 🚀 by Ultralytics, GPL-3.0 license + +# Parameters +nc: 80 # number of classes +depth_multiple: 0.33 # model depth multiple +width_multiple: 0.25 # layer channel multiple +anchors: + - [10,13, 16,30, 33,23] # P3/8 + - [30,61, 62,45, 59,119] # P4/16 + - [116,90, 156,198, 373,326] # P5/32 + +# YOLOv5 v6.0 backbone +backbone: + # [from, number, module, args] + [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 + [-1, 1, Conv, [128, 3, 2]], # 1-P2/4 + [-1, 3, C3, [128]], + [-1, 1, Conv, [256, 3, 2]], # 3-P3/8 + [-1, 6, C3, [256]], + [-1, 1, Conv, [512, 3, 2]], # 5-P4/16 + [-1, 9, C3, [512]], + [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32 + [-1, 3, C3, [1024]], + [-1, 1, SPPF, [1024, 5]], # 9 + ] + +# YOLOv5 v6.0 head +head: + [[-1, 1, Conv, [512, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 6], 1, Concat, [1]], # cat backbone P4 + [-1, 3, C3, [512, False]], # 13 + + [-1, 1, Conv, [256, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 4], 1, Concat, [1]], # cat backbone P3 + [-1, 3, C3, [256, False]], # 17 (P3/8-small) + + [-1, 1, Conv, [256, 3, 2]], + [[-1, 14], 1, Concat, [1]], # cat head P4 + [-1, 3, C3, [512, False]], # 20 (P4/16-medium) + + [-1, 1, Conv, [512, 3, 2]], + [[-1, 10], 1, Concat, [1]], # cat head P5 + [-1, 3, C3, [1024, False]], # 23 (P5/32-large) + + [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5) + ] diff --git a/torchsig/models/spectrogram_models/yolov5/yolov5p.yaml b/torchsig/models/spectrogram_models/yolov5/yolov5p.yaml new file mode 100644 index 0000000..a399a01 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/yolov5p.yaml @@ -0,0 +1,50 @@ +# YOLOv5 🚀 by Ultralytics, GPL-3.0 license + +# Parameters +nc: 80 # number of classes +#depth_multiple: 0.23 # model depth multiple +#width_multiple: 0.1875 # layer channel multiple +depth_multiple: 0.2 +width_multiple: 0.1 +anchors: + - [10,13, 16,30, 33,23] # P3/8 + - [30,61, 62,45, 59,119] # P4/16 + - [116,90, 156,198, 373,326] # P5/32 + +# YOLOv5 v6.0 backbone +backbone: + # [from, number, module, args] + [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 + [-1, 1, Conv, [128, 3, 2]], # 1-P2/4 + [-1, 3, C3, [128]], + [-1, 1, Conv, [256, 3, 2]], # 3-P3/8 + [-1, 6, C3, [256]], + [-1, 1, Conv, [512, 3, 2]], # 5-P4/16 + [-1, 9, C3, [512]], + [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32 + [-1, 3, C3, [1024]], + [-1, 1, SPPF, [1024, 5]], # 9 + ] + +# YOLOv5 v6.0 head +head: + [[-1, 1, Conv, [512, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 6], 1, Concat, [1]], # cat backbone P4 + [-1, 3, C3, [512, False]], # 13 + + [-1, 1, Conv, [256, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 4], 1, Concat, [1]], # cat backbone P3 + [-1, 3, C3, [256, False]], # 17 (P3/8-small) + + [-1, 1, Conv, [256, 3, 2]], + [[-1, 14], 1, Concat, [1]], # cat head P4 + [-1, 3, C3, [512, False]], # 20 (P4/16-medium) + + [-1, 1, Conv, [512, 3, 2]], + [[-1, 10], 1, Concat, [1]], # cat head P5 + [-1, 3, C3, [1024, False]], # 23 (P5/32-large) + + [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5) + ] diff --git a/torchsig/models/spectrogram_models/yolov5/yolov5s.yaml b/torchsig/models/spectrogram_models/yolov5/yolov5s.yaml new file mode 100644 index 0000000..f35beab --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/yolov5s.yaml @@ -0,0 +1,48 @@ +# YOLOv5 🚀 by Ultralytics, GPL-3.0 license + +# Parameters +nc: 80 # number of classes +depth_multiple: 0.33 # model depth multiple +width_multiple: 0.50 # layer channel multiple +anchors: + - [10,13, 16,30, 33,23] # P3/8 + - [30,61, 62,45, 59,119] # P4/16 + - [116,90, 156,198, 373,326] # P5/32 + +# YOLOv5 v6.0 backbone +backbone: + # [from, number, module, args] + [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 + [-1, 1, Conv, [128, 3, 2]], # 1-P2/4 + [-1, 3, C3, [128]], + [-1, 1, Conv, [256, 3, 2]], # 3-P3/8 + [-1, 6, C3, [256]], + [-1, 1, Conv, [512, 3, 2]], # 5-P4/16 + [-1, 9, C3, [512]], + [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32 + [-1, 3, C3, [1024]], + [-1, 1, SPPF, [1024, 5]], # 9 + ] + +# YOLOv5 v6.0 head +head: + [[-1, 1, Conv, [512, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 6], 1, Concat, [1]], # cat backbone P4 + [-1, 3, C3, [512, False]], # 13 + + [-1, 1, Conv, [256, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 4], 1, Concat, [1]], # cat backbone P3 + [-1, 3, C3, [256, False]], # 17 (P3/8-small) + + [-1, 1, Conv, [256, 3, 2]], + [[-1, 14], 1, Concat, [1]], # cat head P4 + [-1, 3, C3, [512, False]], # 20 (P4/16-medium) + + [-1, 1, Conv, [512, 3, 2]], + [[-1, 10], 1, Concat, [1]], # cat head P5 + [-1, 3, C3, [1024, False]], # 23 (P5/32-large) + + [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5) + ] diff --git a/torchsig/models/spectrogram_models/yolov5/yolov5x.yaml b/torchsig/models/spectrogram_models/yolov5/yolov5x.yaml new file mode 100644 index 0000000..f617a02 --- /dev/null +++ b/torchsig/models/spectrogram_models/yolov5/yolov5x.yaml @@ -0,0 +1,48 @@ +# YOLOv5 🚀 by Ultralytics, GPL-3.0 license + +# Parameters +nc: 80 # number of classes +depth_multiple: 1.33 # model depth multiple +width_multiple: 1.25 # layer channel multiple +anchors: + - [10,13, 16,30, 33,23] # P3/8 + - [30,61, 62,45, 59,119] # P4/16 + - [116,90, 156,198, 373,326] # P5/32 + +# YOLOv5 v6.0 backbone +backbone: + # [from, number, module, args] + [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 + [-1, 1, Conv, [128, 3, 2]], # 1-P2/4 + [-1, 3, C3, [128]], + [-1, 1, Conv, [256, 3, 2]], # 3-P3/8 + [-1, 6, C3, [256]], + [-1, 1, Conv, [512, 3, 2]], # 5-P4/16 + [-1, 9, C3, [512]], + [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32 + [-1, 3, C3, [1024]], + [-1, 1, SPPF, [1024, 5]], # 9 + ] + +# YOLOv5 v6.0 head +head: + [[-1, 1, Conv, [512, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 6], 1, Concat, [1]], # cat backbone P4 + [-1, 3, C3, [512, False]], # 13 + + [-1, 1, Conv, [256, 1, 1]], + [-1, 1, nn.Upsample, [None, 2, 'nearest']], + [[-1, 4], 1, Concat, [1]], # cat backbone P3 + [-1, 3, C3, [256, False]], # 17 (P3/8-small) + + [-1, 1, Conv, [256, 3, 2]], + [[-1, 14], 1, Concat, [1]], # cat head P4 + [-1, 3, C3, [512, False]], # 20 (P4/16-medium) + + [-1, 1, Conv, [512, 3, 2]], + [[-1, 10], 1, Concat, [1]], # cat head P5 + [-1, 3, C3, [1024, False]], # 23 (P5/32-large) + + [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5) + ] diff --git a/torchsig/transforms/__init__.py b/torchsig/transforms/__init__.py index 8737964..8c8780a 100644 --- a/torchsig/transforms/__init__.py +++ b/torchsig/transforms/__init__.py @@ -2,6 +2,7 @@ from . import system_impairment from . import wireless_channel from . import signal_processing +from . import spectrogram_transforms from . import deep_learning_techniques from . import target_transforms from .functional import * @@ -10,5 +11,6 @@ from torchsig.transforms.wireless_channel import * from torchsig.transforms.expert_feature import * from torchsig.transforms.signal_processing import * +from torchsig.transforms.spectrogram_transforms import * from torchsig.transforms.deep_learning_techniques import * from torchsig.transforms.target_transforms import * diff --git a/torchsig/transforms/deep_learning_techniques/__init__.py b/torchsig/transforms/deep_learning_techniques/__init__.py index 8aeecd5..58b4958 100644 --- a/torchsig/transforms/deep_learning_techniques/__init__.py +++ b/torchsig/transforms/deep_learning_techniques/__init__.py @@ -1,2 +1,2 @@ from .dlt import * -from .dlt_functional import * +from .functional import * diff --git a/torchsig/transforms/deep_learning_techniques/dlt.py b/torchsig/transforms/deep_learning_techniques/dlt.py index 3be8742..4f996a0 100644 --- a/torchsig/transforms/deep_learning_techniques/dlt.py +++ b/torchsig/transforms/deep_learning_techniques/dlt.py @@ -1,13 +1,15 @@ import numpy as np from copy import deepcopy -from typing import Tuple, List, Any, Union, Optional +from typing import Tuple, List, Any, Union, Optional, Callable from torchsig.utils import SignalDescription, SignalData, SignalDataset from torchsig.transforms.transforms import SignalTransform +from torchsig.transforms.signal_processing import Normalize from torchsig.transforms.wireless_channel import TargetSNR from torchsig.transforms.functional import to_distribution, uniform_continuous_distribution, uniform_discrete_distribution -from torchsig.transforms.functional import NumericParameter, FloatParameter -from torchsig.transforms.deep_learning_techniques import dlt_functional +from torchsig.transforms.functional import NumericParameter, FloatParameter, IntParameter +from torchsig.transforms.deep_learning_techniques import functional +from torchsig.transforms.expert_feature import functional as eft_f class DatasetBasebandMixUp(SignalTransform): @@ -23,7 +25,7 @@ class DatasetBasebandMixUp(SignalTransform): than zero. This transform is loosely based on - `"mixup: Beyond Empirical Risk Minimization" `_. + `"mixup: Beyond Emperical Risk Minimization" `_. Args: @@ -356,10 +358,10 @@ def __call__(self, data: Any) -> Any: new_data.signal_description = new_signal_description # Perform data augmentation - new_data.iq_data = dlt_functional.cut_out(data.iq_data, cut_start, cut_dur, cut_type) + new_data.iq_data = functional.cut_out(data.iq_data, cut_start, cut_dur, cut_type) else: - new_data = dlt_functional.cut_out(data, cut_start, cut_dur, cut_type) + new_data = functional.cut_out(data, cut_start, cut_dur, cut_type) return new_data @@ -408,9 +410,446 @@ def __call__(self, data: Any) -> Any: ) # Perform data augmentation - new_data.iq_data = dlt_functional.patch_shuffle(data.iq_data, patch_size, shuffle_ratio) + new_data.iq_data = functional.patch_shuffle(data.iq_data, patch_size, shuffle_ratio) else: - new_data = dlt_functional.patch_shuffle(data, patch_size, shuffle_ratio) + new_data = functional.patch_shuffle(data, patch_size, shuffle_ratio) return new_data + +class DatasetWidebandCutMix(SignalTransform): + """SignalTransform that inputs a dataset to randomly sample from and insert + into the main dataset's examples, using an additional `alpha` input to set + the relative quantity in time to occupy, where + + cutmix_num_iq_samples = total_num_iq_samples * alpha + + This transform is loosely based on [CutMix: Regularization Strategy to + Train Strong Classifiers with Localizable Features] + (https://arxiv.org/pdf/1710.09412.pdf). + + Args: + dataset :obj:`SignalDataset`: + An SignalDataset of complex-valued examples to be used as a source for + the synthetic insertion/mixup + + alpha (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + alpha sets the difference in durations between the main dataset + example and the inserted example + * If Callable, produces a sample by calling alpha() + * If int or float, alpha is fixed at the value provided + * If list, alpha is any element in the list + * If tuple, alpha is in range of (tuple[0], tuple[1]) + + Example: + >>> import torchsig.transforms as ST + >>> from torchsig.datasets import WidebandSig53 + >>> # Add signals from the `ModulationsDataset` + >>> dataset = WidebandSig53('.') + >>> transform = ST.DatasetWidebandCutMix(dataset=dataset,alpha=(0.2,0.7)) + + """ + def __init__( + self, + dataset: SignalDataset = None, + alpha: NumericParameter = uniform_continuous_distribution(0.2, 0.7), + ): + super(DatasetWidebandCutMix, self).__init__() + self.alpha = to_distribution(alpha, self.random_generator) + self.dataset = dataset + self.dataset_num_samples = len(dataset) + + def __call__(self, data: Any) -> Any: + alpha = self.alpha() + if isinstance(data, SignalData): + # Randomly sample from provided dataset + idx = np.random.randint(self.dataset_num_samples) + insert_data, insert_signal_description = self.dataset[idx] + num_iq_samples = data.iq_data.shape[0] + if insert_data.shape[0] != num_iq_samples: + raise ValueError( + "Input dataset's `num_iq_samples` does not match main dataset.\n\t\ + Found {}, but expected {} samples" + .format(insert_data.shape[0],data.shape[0]) + ) + + # Mask both data examples based on alpha and a random start value + insert_num_iq_samples = int(alpha * num_iq_samples) + insert_start = np.random.randint(num_iq_samples - insert_num_iq_samples) + insert_stop = insert_start+insert_num_iq_samples + data.iq_data[insert_start:insert_stop] = 0 + insert_data[:insert_start] = 0 + insert_data[insert_stop:] = 0 + insert_start /= num_iq_samples + insert_dur = insert_num_iq_samples / num_iq_samples + + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=[], + ) + new_data.iq_data = data.iq_data + insert_data + + # Update SignalDescription + new_signal_description = [] + signal_description = [data.signal_description] if isinstance(data.signal_description, SignalDescription) else data.signal_description + for signal_desc in signal_description: + new_signal_desc = deepcopy(signal_desc) + + # Update labels + if new_signal_desc.start > insert_start and new_signal_desc.start < insert_start + insert_dur: + # Label starts within cut region + if new_signal_desc.stop > insert_start and new_signal_desc.stop < insert_start + insert_dur: + # Label also stops within cut region --> Remove label + continue + else: + # Push label start to end of cut region + new_signal_desc.start = insert_start + insert_dur + elif new_signal_desc.stop > insert_start and new_signal_desc.stop < insert_start + insert_dur: + # Label stops within cut region but does not start in region --> Push stop to begining of cut region + new_signal_desc.stop = insert_start + elif new_signal_desc.start < insert_start and new_signal_desc.stop > insert_start + insert_dur: + # Label traverse cut region --> Split into two labels + new_signal_desc_split = deepcopy(signal_desc) + # Update first label region's stop + new_signal_desc.stop = insert_start + # Update second label region's start & append to description collection + new_signal_desc_split.start = insert_start + insert_dur + new_signal_description.append(new_signal_desc_split) + + # Append SignalDescription to list + new_signal_description.append(new_signal_desc) + + # Repeat for inserted example's SignalDescription(s) + for insert_signal_desc in insert_signal_description: + # Update labels + if insert_signal_desc.stop < insert_start or insert_signal_desc.start > insert_start + insert_dur: + # Label is outside inserted region --> Remove label + continue + elif insert_signal_desc.start < insert_start and insert_signal_desc.stop < insert_start + insert_dur: + # Label starts before and ends within region, push start to region start + insert_signal_desc.start = insert_start + elif insert_signal_desc.start >= insert_start and insert_signal_desc.stop > insert_start + insert_dur: + # Label starts within region and stops after, push stop to region stop + insert_signal_desc.stop = insert_start + insert_dur + elif insert_signal_desc.start < insert_start and insert_signal_desc.stop > insert_start + insert_dur: + # Label starts before and stops after, push both start & stop to region boundaries + insert_signal_desc.start = insert_start + insert_signal_desc.stop = insert_start + insert_dur + + # Append SignalDescription to list + new_signal_description.append(insert_signal_desc) + + # Set output data's SignalDescription to above list + new_data.signal_description = new_signal_description + + return new_data + else: + raise ValueError( + "Expected input type `SignalData`. Received {}. \n\t\ + The `DatasetWidebandCutMix` transform depends on metadata from a `SignalData` object." + .format(type(data)) + ) + + +class DatasetWidebandMixUp(SignalTransform): + """SignalTransform that inputs a dataset to randomly sample from and insert + into the main dataset's examples, using the `alpha` input to set the + difference in magnitudes between the two examples with the following + relationship: + + output_sample = main_sample * (1 - alpha) + mixup_sample * alpha + + This transform is loosely based on [mixup: Beyond Emperical Risk + Minimization](https://arxiv.org/pdf/1710.09412.pdf). + + Args: + dataset :obj:`SignalDataset`: + An SignalDataset of complex-valued examples to be used as a source for + the synthetic insertion/mixup + + alpha (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + alpha sets the difference in power level between the main dataset + example and the inserted example + * If Callable, produces a sample by calling alpha() + * If int or float, alpha is fixed at the value provided + * If list, alpha is any element in the list + * If tuple, alpha is in range of (tuple[0], tuple[1]) + + Example: + >>> import torchsig.transforms as ST + >>> from torchsig.datasets import WidebandSig53 + >>> # Add signals from the `WidebandSig53` Dataset + >>> dataset = WidebandSig53('.') + >>> transform = ST.DatasetWidebandMixUp(dataset=dataset,alpha=(0.4,0.6)) + + """ + def __init__( + self, + dataset: SignalDataset = None, + alpha: NumericParameter = uniform_continuous_distribution(0.4, 0.6), + ): + super(DatasetWidebandMixUp, self).__init__() + self.alpha = to_distribution(alpha, self.random_generator) + self.dataset = dataset + self.dataset_num_samples = len(dataset) + + def __call__(self, data: Any) -> Any: + alpha = self.alpha() + if isinstance(data, SignalData): + # Randomly sample from provided dataset + idx = np.random.randint(self.dataset_num_samples) + insert_data, insert_signal_description = self.dataset[idx] + if insert_data.shape[0] != data.iq_data.shape[0]: + raise ValueError( + "Input dataset's `num_iq_samples` does not match main dataset.\n\t\ + Found {}, but expected {} samples" + .format(insert_data.shape[0],data.shape[0]) + ) + + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=[], + ) + new_data.iq_data = data.iq_data * (1 - alpha) + insert_data * alpha + + # Update SignalDescription + new_signal_description = [] + new_signal_description.extend(data.signal_description) + new_signal_description.extend(insert_signal_description) + new_data.signal_description = new_signal_description + + return new_data + else: + raise ValueError( + "Expected input type `SignalData`. Received {}. \n\t\ + The `DatasetWidebandMixUp` transform depends on metadata from a `SignalData` object." + .format(type(data)) + ) + + +class SpectrogramRandomResizeCrop(SignalTransform): + """The SpectrogramRandomResizeCrop transforms the input IQ data into a + spectrogram with a randomized FFT size and overlap. This randomization in + the spectrogram computation results in spectrograms of various sizes. The + width and height arguments specify the target output size of the transform. + To get to the desired size, the randomly generated spectrogram may be + randomly cropped or padded in either the time or frequency dimensions. This + transform is meant to emulate the Random Resize Crop transform often used + in computer vision tasks. + + Args: + nfft (:py:class:`~Callable`, :obj:`int`, :obj:`list`, :obj:`tuple`): + The number of FFT bins for the random spectrogram. + * If Callable, nfft is set by calling nfft() + * If int, nfft is fixed by value provided + * If list, nfft is any element in the list + * If tuple, nfft is in range of (tuple[0], tuple[1]) + overlap_ratio (:py:class:`~Callable`, :obj:`int`, :obj:`list`, :obj:`tuple`): + The ratio of the (nfft-1) value to use as the overlap parameter for + the spectrogram operation. Setting as ratio ensures the overlap is + a lower value than the bin size. + * If Callable, nfft is set by calling overlap_ratio() + * If float, overlap_ratio is fixed by value provided + * If list, overlap_ratio is any element in the list + * If tuple, overlap_ratio is in range of (tuple[0], tuple[1]) + window_fcn (:obj:`str`): + Window to be used in spectrogram operation. + Default value is 'np.blackman'. + mode (:obj:`str`): + Mode of the spectrogram to be computed. + Default value is 'complex'. + width (:obj:`int`): + Target output width (time) of the spectrogram + height (:obj:`int`): + Target output height (frequency) of the spectrogram + + Example: + >>> import torchsig.transforms as ST + >>> # Randomly sample NFFT size in range [128,1024] and randomly crop/pad output spectrogram to (512,512) + >>> transform = ST.SpectrogramRandomResizeCrop(nfft=(128,1024), overlap_ratio=(0.0,0.2), width=512, height=512) + + """ + def __init__( + self, + nfft: IntParameter = (256, 1024), + overlap_ratio: FloatParameter = (0.0,0.2), + window_fcn: Callable[[int], np.ndarray] = np.blackman, + mode: str = 'complex', + width: int = 512, + height: int = 512, + ): + super(SpectrogramRandomResizeCrop, self).__init__() + self.nfft = to_distribution(nfft, self.random_generator) + self.overlap_ratio = to_distribution(overlap_ratio, self.random_generator) + self.window_fcn = window_fcn + self.mode = mode + self.width = width + self.height = height + + def __call__(self, data: Any) -> Any: + nfft = int(self.nfft()) + nperseg = nfft + overlap_ratio = self.overlap_ratio() + noverlap = int(overlap_ratio * (nfft-1)) + + iq_data = data.iq_data if isinstance(data, SignalData) else data + + # First, perform the random spectrogram operation + spec_data = eft_f.spectrogram(iq_data, nperseg, noverlap, nfft, self.window_fcn, self.mode) + if self.mode == "complex": + new_tensor = np.zeros((2, spec_data.shape[0], spec_data.shape[1]), dtype=np.float32) + new_tensor[0, :, :] = np.real(spec_data).astype(np.float32) + new_tensor[1, :, :] = np.imag(spec_data).astype(np.float32) + spec_data = new_tensor + + # Next, perform the random cropping/padding + channels, curr_height, curr_width = spec_data.shape + pad_height, crop_height = False, False + pad_width, crop_width = False, False + pad_height_samps, pad_width_samps = 0, 0 + if curr_height < self.height: + pad_height = True + pad_height_samps = self.height - curr_height + elif curr_height > self.height: + crop_height = True + if curr_width < self.width: + pad_width = True + pad_width_samps = self.width - curr_width + elif curr_width > self.width: + crop_width = True + + if pad_height or pad_width: + def pad_func(vector, pad_width, iaxis, kwargs): + vector[:pad_width[0]] = np.random.rand(len(vector[:pad_width[0]]))*kwargs['pad_value'] + vector[-pad_width[1]:] = np.random.rand(len(vector[-pad_width[1]:]))*kwargs['pad_value'] + + pad_height_start = np.random.randint(0,pad_height_samps//2+1) + pad_height_end = pad_height_samps - pad_height_start + 1 + pad_width_start = np.random.randint(0,pad_width_samps//2+1) + pad_width_end = pad_width_samps - pad_width_start + 1 + + if self.mode == "complex": + new_data_real = np.pad( + spec_data[0], + ( + (pad_height_start,pad_height_end), + (pad_width_start,pad_width_end), + ), + pad_func, + pad_value = np.percentile(np.abs(spec_data[0]),50), + ) + new_data_imag = np.pad( + spec_data[1], + ( + (pad_height_start,pad_height_end), + (pad_width_start,pad_width_end), + ), + pad_func, + pad_value = np.percentile(np.abs(spec_data[1]),50), + ) + spec_data = np.concatenate( + [ + np.expand_dims(new_data_real,axis=0), + np.expand_dims(new_data_imag,axis=0) + ], + axis=0, + ) + else: + spec_data = np.pad( + spec_data, + ( + (pad_height_start,pad_height_end), + (pad_width_start,pad_width_end), + ), + pad_func, + min_value = np.percentile(np.abs(spec_data[0]),50), + ) + + crop_width_start = np.random.randint(0,max(1,curr_width-self.width)) + crop_height_start = np.random.randint(0,max(1,curr_height-self.height)) + spec_data = spec_data[ + :, + crop_height_start:crop_height_start+self.height, + crop_width_start:crop_width_start+self.width, + ] + + # Update SignalData object if necessary, otherwise return + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=[], + ) + new_data.iq_data = spec_data + + # Update SignalDescription + new_signal_description = [] + signal_description = [data.signal_description] if isinstance(data.signal_description, SignalDescription) else data.signal_description + for signal_desc in signal_description: + new_signal_desc = deepcopy(signal_desc) + + # Check bounds for partial signals + new_signal_desc.lower_frequency = -0.5 if new_signal_desc.lower_frequency < -0.5 else new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + # Update labels based on padding/cropping + if pad_height: + new_signal_desc.lower_frequency = ((new_signal_desc.lower_frequency+0.5)*curr_height + pad_height_start) / self.height - 0.5 + new_signal_desc.upper_frequency = ((new_signal_desc.upper_frequency+0.5)*curr_height + pad_height_start) / self.height - 0.5 + new_signal_desc.center_frequency = ((new_signal_desc.center_frequency+0.5)*curr_height + pad_height_start) / self.height - 0.5 + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + + if crop_height: + if (new_signal_desc.lower_frequency+0.5)*curr_height >= crop_height_start+self.height or \ + (new_signal_desc.upper_frequency+0.5)*curr_height <= crop_height_start: + continue + if (new_signal_desc.lower_frequency+0.5)*curr_height <= crop_height_start: + new_signal_desc.lower_frequency = -0.5 + else: + new_signal_desc.lower_frequency = ((new_signal_desc.lower_frequency+0.5)*curr_height - crop_height_start) / self.height - 0.5 + if (new_signal_desc.upper_frequency+0.5)*curr_height >= crop_height_start+self.height: + new_signal_desc.upper_frequency = crop_height_start+self.height + else: + new_signal_desc.upper_frequency = ((new_signal_desc.upper_frequency+0.5)*curr_height - crop_height_start) / self.height - 0.5 + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth / 2 + + if pad_width: + new_signal_desc.start = (new_signal_desc.start * curr_width + pad_width_start) / self.width + new_signal_desc.stop = (new_signal_desc.stop * curr_width + pad_width_start) / self.width + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + if crop_width: + if new_signal_desc.start*curr_width <= crop_width_start: + new_signal_desc.start = 0.0 + elif new_signal_desc.start*curr_width >= crop_width_start+self.width: + continue + else: + new_signal_desc.start = (new_signal_desc.start * curr_width - crop_width_start) / self.width + if new_signal_desc.stop*curr_width >= crop_width_start+self.width: + new_signal_desc.stop = 1.0 + elif new_signal_desc.stop*curr_width <= crop_width_start: + continue + else: + new_signal_desc.stop = (new_signal_desc.stop * curr_width - crop_width_start) / self.width + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + # Append SignalDescription to list + new_signal_description.append(new_signal_desc) + + new_data.signal_description = new_signal_description + + else: + new_data = spec_data + + return new_data diff --git a/torchsig/transforms/deep_learning_techniques/functional.py b/torchsig/transforms/deep_learning_techniques/functional.py new file mode 100644 index 0000000..e9ea386 --- /dev/null +++ b/torchsig/transforms/deep_learning_techniques/functional.py @@ -0,0 +1,102 @@ +import numpy as np + + +def cut_out( + tensor: np.ndarray, + cut_start: float, + cut_dur: float, + cut_type: str, +) -> np.ndarray: + """Performs the CutOut using the input parameters + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + cut_start: (:obj:`float`): + Start of cut region in range [0.0,1.0) + + cut_dur: (:obj:`float`): + Duration of cut region in range (0.0,1.0] + + cut_type: (:obj:`str`): + String specifying type of data to fill in cut region with + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone cut out + + """ + num_iq_samples = tensor.shape[0] + cut_start = int(cut_start * num_iq_samples) + + # Create cut mask + cut_mask_length = int(num_iq_samples * cut_dur) + if cut_mask_length + cut_start > num_iq_samples: + cut_mask_length = num_iq_samples - cut_start + + if cut_type == "zeros": + cut_mask = np.zeros(cut_mask_length, dtype=np.complex64) + elif cut_type == "ones": + cut_mask = np.ones(cut_mask_length) + 1j*np.ones(cut_mask_length) + elif cut_type == "low_noise": + real_noise = np.random.randn(cut_mask_length) + imag_noise = np.random.randn(cut_mask_length) + noise_power_db = -100 + cut_mask = (10.0**(noise_power_db/20.0))*(real_noise + 1j*imag_noise)/np.sqrt(2) + elif cut_type == "avg_noise": + real_noise = np.random.randn(cut_mask_length) + imag_noise = np.random.randn(cut_mask_length) + avg_power = np.mean(np.abs(tensor)**2) + cut_mask = avg_power*(real_noise + 1j*imag_noise)/np.sqrt(2) + elif cut_type == "high_noise": + real_noise = np.random.randn(cut_mask_length) + imag_noise = np.random.randn(cut_mask_length) + noise_power_db = 40 + cut_mask = (10.0**(noise_power_db/20.0))*(real_noise + 1j*imag_noise)/np.sqrt(2) + else: + raise ValueError("cut_type must be: zeros, ones, low_noise, avg_noise, or high_noise. Found: {}".format(cut_type)) + + # Insert cut mask into tensor + tensor[cut_start:cut_start+cut_mask_length] = cut_mask + + return tensor + + +def patch_shuffle( + tensor: np.ndarray, + patch_size: int, + shuffle_ratio: float, +) -> np.ndarray: + """Apply shuffling of patches specified by `num_patches` + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + patch_size (:obj:`int`): + Size of each patch to shuffle + + shuffle_ratio (:obj:`float`): + Ratio of patches to shuffle + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone patch shuffling + + """ + num_patches = int(tensor.shape[0] / patch_size) + num_to_shuffle = int(num_patches * shuffle_ratio) + patches_to_shuffle = np.random.choice( + num_patches, + replace=False, + size=num_to_shuffle, + ) + + for patch_idx in patches_to_shuffle: + patch_start = int(patch_idx * patch_size) + patch = tensor[patch_start:patch_start+patch_size] + np.random.shuffle(patch) + tensor[patch_start:patch_start+patch_size] = patch + + return tensor diff --git a/torchsig/transforms/expert_feature/__init__.py b/torchsig/transforms/expert_feature/__init__.py index 01ac526..ec96146 100644 --- a/torchsig/transforms/expert_feature/__init__.py +++ b/torchsig/transforms/expert_feature/__init__.py @@ -1,2 +1,2 @@ from .eft import * -from .eft_functional import * +from .functional import * diff --git a/torchsig/transforms/expert_feature/eft.py b/torchsig/transforms/expert_feature/eft.py index aecbfdb..ea79d6a 100644 --- a/torchsig/transforms/expert_feature/eft.py +++ b/torchsig/transforms/expert_feature/eft.py @@ -2,7 +2,7 @@ from typing import Callable, Tuple, Any from torchsig.utils.types import SignalData -from torchsig.transforms.expert_feature import eft_functional as F +from torchsig.transforms.expert_feature import functional as F from torchsig.transforms.transforms import SignalTransform @@ -170,7 +170,7 @@ def __call__(self, data: Any) -> Any: class Spectrogram(SignalTransform): - """ Calculates power spectral density over time + """Calculates power spectral density over time Args: nperseg (:obj:`int`): @@ -224,14 +224,14 @@ def __init__( def __call__(self, data: Any) -> Any: if isinstance(data, SignalData): - data.iq_data = F.spectrogram(data.iq_data) + data.iq_data = F.spectrogram(data.iq_data, self.nperseg, self.noverlap, self.nfft, self.window_fcn, self.mode) if self.mode == "complex": new_tensor = np.zeros((2, data.iq_data.shape[0], data.iq_data.shape[1]), dtype=np.float32) new_tensor[0, :, :] = np.real(data.iq_data).astype(np.float32) new_tensor[1, :, :] = np.imag(data.iq_data).astype(np.float32) data.iq_data = new_tensor else: - data = F.spectrogram(data) + data = F.spectrogram(data, self.nperseg, self.noverlap, self.nfft, self.window_fcn, self.mode) if self.mode == "complex": new_tensor = np.zeros((2, data.shape[0], data.shape[1]), dtype=np.float32) new_tensor[0, :, :] = np.real(data).astype(np.float32) diff --git a/torchsig/transforms/expert_feature/functional.py b/torchsig/transforms/expert_feature/functional.py new file mode 100644 index 0000000..729d12d --- /dev/null +++ b/torchsig/transforms/expert_feature/functional.py @@ -0,0 +1,201 @@ +import pywt +import numpy as np +from scipy import signal +from typing import Callable + + +def interleave_complex(tensor: np.ndarray) -> np.ndarray: + """Converts complex vectors to real interleaved IQ vector + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + Interleaved vectors. + """ + new_tensor = np.empty((tensor.shape[0]*2,)) + new_tensor[::2] = np.real(tensor) + new_tensor[1::2] = np.imag(tensor) + return new_tensor + + +def complex_to_2d(tensor: np.ndarray) -> np.ndarray: + """Converts complex IQ to two channels representing real and imaginary + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + Expanded vectors + """ + + new_tensor = np.zeros((2, tensor.shape[0]), dtype=np.float64) + new_tensor[0] = np.real(tensor).astype(np.float64) + new_tensor[1] = np.imag(tensor).astype(np.float64) + return new_tensor + + +def real(tensor: np.ndarray) -> np.ndarray: + """Converts complex IQ to a real-only vector + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + real(tensor) + """ + return np.real(tensor) + + +def imag(tensor: np.ndarray) -> np.ndarray: + """Converts complex IQ to a imaginary-only vector + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + imag(tensor) + """ + return np.imag(tensor) + + +def complex_magnitude(tensor: np.ndarray) -> np.ndarray: + """Converts complex IQ to a complex magnitude vector + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + abs(tensor) + """ + return np.abs(tensor) + + +def wrapped_phase(tensor: np.ndarray) -> np.ndarray: + """Converts complex IQ to a wrapped-phase vector + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + angle(tensor) + """ + return np.angle(tensor) + + +def discrete_fourier_transform(tensor: np.ndarray) -> np.ndarray: + """Computes DFT of complex IQ vector + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + fft(tensor). normalization is 1/sqrt(n) + """ + return np.fft.fft(tensor, norm="ortho") + + +def spectrogram( + tensor: np.ndarray, + nperseg: int, + noverlap: int, + nfft: int, + window_fcn: Callable[[int], np.ndarray], + mode: str, +) -> np.ndarray: + """Computes spectrogram of complex IQ vector + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + nperseg (:obj:`int`): + Length of each segment. If window is str or tuple, is set to 256, + and if window is array_like, is set to the length of the window. + + noverlap (:obj:`int`): + Number of points to overlap between segments. + If None, noverlap = nperseg // 8. + + nfft (:obj:`int`): + Length of the FFT used, if a zero padded FFT is desired. + If None, the FFT length is nperseg. + + window_fcn (:obj:`Callable`): + Function generating the window for each FFT + + mode (:obj:`str`): + Mode of the spectrogram to be computed. + + Returns: + transformed (:class:`numpy.ndarray`): + Spectrogram of tensor along time dimension + """ + _, _, spectrograms = signal.spectrogram( + tensor, + nperseg=nperseg, + noverlap=noverlap, + nfft=nfft, + window=window_fcn(nperseg), + return_onesided=False, + mode=mode, + axis=0 + ) + return np.fft.fftshift(spectrograms, axes=0) + + +def continuous_wavelet_transform( + tensor: np.ndarray, + wavelet: str, + nscales: int, + sample_rate: float +) -> np.ndarray: + """Computes the continuous wavelet transform resulting in a Scalogram of the complex IQ vector + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + wavelet (:obj:`str`): + Name of the mother wavelet. + If None, wavename = 'mexh'. + + nscales (:obj:`int`): + Number of scales to use in the Scalogram. + If None, nscales = 33. + + sample_rate (:obj:`float`): + Sample rate of the signal. + If None, fs = 1.0. + + Returns: + transformed (:class:`numpy.ndarray`): + Scalogram of tensor along time dimension + """ + scales = np.arange(1, nscales) + cwtmatr, _ = pywt.cwt( + tensor, + scales=scales, + wavelet=wavelet, + sampling_period=1.0/sample_rate + ) + + # if the dtype is complex then return the magnitude + if np.iscomplexobj(cwtmatr): + cwtmatr = abs(cwtmatr) + + return cwtmatr diff --git a/torchsig/transforms/functional.py b/torchsig/transforms/functional.py index c13e38f..2303bed 100644 --- a/torchsig/transforms/functional.py +++ b/torchsig/transforms/functional.py @@ -1,32 +1,13 @@ -from typing import Callable, List, Protocol, Sequence, Tuple, Union +from typing import Callable, Union, Tuple, List from functools import partial import numpy as np -import numpy.typing as npt FloatParameter = Union[Callable[[int], float], float, Tuple[float, float], List] IntParameter = Union[Callable[[int], int], int, Tuple[int, int], List] NumericParameter = Union[FloatParameter, IntParameter] -class RandomStatePartial(Protocol): - """Type definition for the partially applied random distribution function - returned by the functions in this module. - - These partials can be either called with zero arguments, in which case a - single value is returned, or by passing in a size parameter, in which case - a np.ndarray of the specified shape is returned. - - See: https://peps.python.org/pep-0544/ - See: https://mypy.readthedocs.io/en/stable/protocols.html#callback-protocols - """ - def __call__(self, size: Union[int, Sequence[int]] = ...) -> npt.ArrayLike: - ... - - -def uniform_discrete_distribution( - choices: List, - random_generator: np.random.RandomState = np.random.RandomState() -) -> RandomStatePartial: +def uniform_discrete_distribution(choices: List, random_generator: np.random.RandomState = np.random.RandomState()): return partial(random_generator.choice, choices) @@ -34,14 +15,11 @@ def uniform_continuous_distribution( lower: Union[int, float], upper: Union[int, float], random_generator: np.random.RandomState = np.random.RandomState() -) -> RandomStatePartial: +): return partial(random_generator.uniform, lower, upper) -def to_distribution( - param: NumericParameter, - random_generator: np.random.RandomState = np.random.RandomState() -) -> RandomStatePartial: +def to_distribution(param, random_generator: np.random.RandomState = np.random.RandomState()): if isinstance(param, Callable): return param diff --git a/torchsig/transforms/signal_processing/__init__.py b/torchsig/transforms/signal_processing/__init__.py index 22642dc..a6ce1d4 100644 --- a/torchsig/transforms/signal_processing/__init__.py +++ b/torchsig/transforms/signal_processing/__init__.py @@ -1,2 +1,2 @@ from .sp import * -from .sp_functional import * +from .functional import * diff --git a/torchsig/transforms/signal_processing/functional.py b/torchsig/transforms/signal_processing/functional.py new file mode 100644 index 0000000..e7c7057 --- /dev/null +++ b/torchsig/transforms/signal_processing/functional.py @@ -0,0 +1,92 @@ +import numpy as np +from scipy import signal + + +def normalize(tensor: np.ndarray, norm_order: int = 2, flatten: bool = False) -> np.ndarray: + """Scale a tensor so that a specfied norm computes to 1. For detailed information, see :func:`numpy.linalg.norm.` + * For norm=1, norm = max(sum(abs(x), axis=0)) (sum of the elements) + * for norm=2, norm = sqrt(sum(abs(x)^2), axis=0) (square-root of the sum of squares) + * for norm=np.inf, norm = max(sum(abs(x), axis=1)) (largest absolute value) + + Args: + tensor (:class:`numpy.ndarray`)): + (batch_size, vector_length, ...)-sized tensor to be normalized. + + norm_order (:class:`int`)): + norm order to be passed to np.linalg.norm + + flatten (:class:`bool`)): + boolean specifying if the input array's norm should be calculated on the flattened representation of the input tensor + + Returns: + Tensor: + Normalized complex array. + """ + if flatten: + flat_tensor = tensor.reshape(tensor.size) + norm = np.linalg.norm(flat_tensor, norm_order, keepdims=True) + else: + norm = np.linalg.norm(tensor, norm_order, keepdims=True) + return np.multiply(tensor, 1.0/norm) + + +def resample( + tensor: np.ndarray, + up_rate: int, + down_rate: int, + num_iq_samples: int, + keep_samples: bool, + anti_alias_lpf: bool = False, +) -> np.ndarray: + """Resample a tensor by rational value + + Args: + tensor (:class:`numpy.ndarray`): + tensor to be resampled. + + up_rate (:class:`int`): + rate at which to up-sample the tensor + + down_rate (:class:`int`): + rate at which to down-sample the tensor + + num_iq_samples (:class:`int`): + number of IQ samples to have after resampling + + keep_samples (:class:`bool`): + boolean to specify if the resampled data should be returned as is + + anti_alias_lpf (:class:`bool`)): + boolean to specify if an additional anti aliasing filter should be + applied + + Returns: + Tensor: + Resampled tensor + """ + if anti_alias_lpf: + new_rate = up_rate/down_rate + # Filter around center to future bandwidth + num_taps = int(2*np.ceil(50*2*np.pi/new_rate/.125/22)) # fred harris rule of thumb * 2 + taps = signal.firwin( + num_taps, + new_rate*0.98, + width=new_rate * .02, + window=signal.get_window("blackman", num_taps), + scale=True + ) + tensor = signal.fftconvolve(tensor, taps, mode="same") + + # Resample + resampled = signal.resample_poly(tensor, up_rate, down_rate) + + # Handle extra or not enough IQ samples + if keep_samples: + new_tensor = resampled + elif resampled.shape[0] > num_iq_samples: + new_tensor = resampled[-num_iq_samples:] + else: + new_tensor = np.zeros((num_iq_samples,), dtype=np.complex128) + new_tensor[:resampled.shape[0]] = resampled + + return new_tensor diff --git a/torchsig/transforms/signal_processing/sp.py b/torchsig/transforms/signal_processing/sp.py index 77dedc5..4f04770 100644 --- a/torchsig/transforms/signal_processing/sp.py +++ b/torchsig/transforms/signal_processing/sp.py @@ -4,7 +4,7 @@ from torchsig.utils.types import SignalData, SignalDescription from torchsig.transforms.transforms import SignalTransform -from torchsig.transforms.signal_processing import sp_functional as F +from torchsig.transforms.signal_processing import functional as F from torchsig.transforms.functional import NumericParameter, to_distribution diff --git a/torchsig/transforms/spectrogram_transforms/__init__.py b/torchsig/transforms/spectrogram_transforms/__init__.py new file mode 100644 index 0000000..220064b --- /dev/null +++ b/torchsig/transforms/spectrogram_transforms/__init__.py @@ -0,0 +1,2 @@ +from .spec import * +from .functional import * diff --git a/torchsig/transforms/spectrogram_transforms/functional.py b/torchsig/transforms/spectrogram_transforms/functional.py new file mode 100644 index 0000000..77c769b --- /dev/null +++ b/torchsig/transforms/spectrogram_transforms/functional.py @@ -0,0 +1,168 @@ +import numpy as np + + +def drop_spec_samples( + tensor: np.ndarray, + drop_starts: np.ndarray, + drop_sizes: np.ndarray, + fill: str, +) -> np.ndarray: + """Drop samples at specified input locations/durations with fill technique + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + drop_starts (:class:`numpy.ndarray`): + Indices of where drops start + + drop_sizes (:class:`numpy.ndarray`): + Durations of each drop instance + + fill (:obj:`str`): + String specifying how the dropped samples should be replaced + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone the dropped samples + + """ + flat_spec = tensor.reshape(tensor.shape[0], tensor.shape[1]*tensor.shape[2]) + for idx, drop_start in enumerate(drop_starts): + if fill == "ffill": + drop_region_real = np.ones(drop_sizes[idx])*flat_spec[0,drop_start-1] + drop_region_complex = np.ones(drop_sizes[idx])*flat_spec[1,drop_start-1] + flat_spec[0,drop_start:drop_start+drop_sizes[idx]] = drop_region_real + flat_spec[1,drop_start:drop_start+drop_sizes[idx]] = drop_region_complex + elif fill == "bfill": + drop_region_real = np.ones(drop_sizes[idx])*flat_spec[0,drop_start+drop_sizes[idx]] + drop_region_complex = np.ones(drop_sizes[idx])*flat_spec[1,drop_start+drop_sizes[idx]] + flat_spec[0,drop_start:drop_start+drop_sizes[idx]] = drop_region_real + flat_spec[1,drop_start:drop_start+drop_sizes[idx]] = drop_region_complex + elif fill == "mean": + drop_region_real = np.ones(drop_sizes[idx])*np.mean(flat_spec[0]) + drop_region_complex = np.ones(drop_sizes[idx])*np.mean(flat_spec[1]) + flat_spec[0,drop_start:drop_start+drop_sizes[idx]] = drop_region_real + flat_spec[1,drop_start:drop_start+drop_sizes[idx]] = drop_region_complex + elif fill == "zero": + drop_region = np.zeros(drop_sizes[idx]) + flat_spec[:,drop_start:drop_start+drop_sizes[idx]] = drop_region + elif fill == "min": + drop_region_real = np.ones(drop_sizes[idx])*np.min(np.abs(flat_spec[0])) + drop_region_complex = np.ones(drop_sizes[idx])*np.min(np.abs(flat_spec[1])) + flat_spec[0,drop_start:drop_start+drop_sizes[idx]] = drop_region_real + flat_spec[1,drop_start:drop_start+drop_sizes[idx]] = drop_region_complex + elif fill == "max": + drop_region_real = np.ones(drop_sizes[idx])*np.max(np.abs(flat_spec[0])) + drop_region_complex = np.ones(drop_sizes[idx])*np.max(np.abs(flat_spec[1])) + flat_spec[0,drop_start:drop_start+drop_sizes[idx]] = drop_region_real + flat_spec[1,drop_start:drop_start+drop_sizes[idx]] = drop_region_complex + elif fill == "low": + drop_region = np.ones(drop_sizes[idx])*1e-3 + flat_spec[:,drop_start:drop_start+drop_sizes[idx]] = drop_region + elif fill == "ones": + drop_region = np.ones(drop_sizes[idx]) + flat_spec[:,drop_start:drop_start+drop_sizes[idx]] = drop_region + else: + raise ValueError("fill expects ffill, bfill, mean, zero, min, max, low, ones. Found {}".format(fill)) + new_tensor = flat_spec.reshape(tensor.shape[0], tensor.shape[1], tensor.shape[2]) + return new_tensor + + +def spec_patch_shuffle( + tensor: np.ndarray, + patch_size: int, + shuffle_ratio: float, +) -> np.ndarray: + """Apply shuffling of patches specified by `num_patches` + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + patch_size (:obj:`int`): + Size of each patch to shuffle + + shuffle_ratio (:obj:`float`): + Ratio of patches to shuffle + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone patch shuffling + + """ + channels, height, width = tensor.shape + num_freq_patches = int(height/patch_size) + num_time_patches = int(width/patch_size) + num_patches = int(num_freq_patches * num_time_patches) + num_to_shuffle = int(num_patches * shuffle_ratio) + patches_to_shuffle = np.random.choice( + num_patches, + replace=False, + size=num_to_shuffle, + ) + + for patch_idx in patches_to_shuffle: + freq_idx = np.floor(patch_idx / num_freq_patches) + time_idx = patch_idx % num_time_patches + patch = tensor[ + :, + int(freq_idx*patch_size):int(freq_idx*patch_size+patch_size), + int(time_idx*patch_size):int(time_idx*patch_size+patch_size) + ] + patch = patch.reshape(int(2*patch_size*patch_size)) + np.random.shuffle(patch) + patch = patch.reshape(2,int(patch_size),int(patch_size)) + tensor[ + :, + int(freq_idx*patch_size):int(freq_idx*patch_size+patch_size), + int(time_idx*patch_size):int(time_idx*patch_size+patch_size) + ] = patch + return tensor + + +def spec_translate( + tensor: np.ndarray, + time_shift: int, + freq_shift: int, +) -> np.ndarray: + """Apply time/freq translation to input spectrogram + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + time_shift (:obj:`int`): + Time shift + + freq_shift (:obj:`int`): + Frequency shift + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone time/freq translation + + """ + # Pre-fill the data with background noise + new_tensor = np.random.rand(*tensor.shape)*np.percentile(np.abs(tensor),50) + + # Apply translation + channels, height, width = tensor.shape + if time_shift >= 0 and freq_shift >= 0: + valid_dur = width - time_shift + valid_bw = height - freq_shift + new_tensor[:,freq_shift:,time_shift:] = tensor[:,:valid_bw,:valid_dur] + elif time_shift < 0 and freq_shift >= 0: + valid_dur = width + time_shift + valid_bw = height - freq_shift + new_tensor[:,freq_shift:,:valid_dur] = tensor[:,:valid_bw,-time_shift:] + elif time_shift >= 0 and freq_shift < 0: + valid_dur = width - time_shift + valid_bw = height + freq_shift + new_tensor[:,:valid_bw,time_shift:] = tensor[:,-freq_shift:,:valid_dur] + elif time_shift < 0 and freq_shift < 0: + valid_dur = width + time_shift + valid_bw = height + freq_shift + new_tensor[:,:valid_bw,:valid_dur] = tensor[:,-freq_shift:,-time_shift:] + + return new_tensor diff --git a/torchsig/transforms/spectrogram_transforms/spec.py b/torchsig/transforms/spectrogram_transforms/spec.py new file mode 100644 index 0000000..54adf14 --- /dev/null +++ b/torchsig/transforms/spectrogram_transforms/spec.py @@ -0,0 +1,744 @@ +import numpy as np +from copy import deepcopy +from typing import Optional, Any, Union, List + +from torchsig.utils.dataset import SignalDataset +from torchsig.utils.types import SignalData, SignalDescription +from torchsig.transforms.transforms import SignalTransform +from torchsig.transforms.spectrogram_transforms import functional +from torchsig.transforms.functional import NumericParameter, FloatParameter, IntParameter +from torchsig.transforms.functional import to_distribution, uniform_continuous_distribution, uniform_discrete_distribution + + +class SpectrogramResize(SignalTransform): + """SpectrogramResize inputs data that has already been transformed into a + spectrogram, and then it crops and/or pads both the time and frequency + dimensions to reach a specified target width (time) and height (frequency). + + Args: + width (:obj:`int`): + Target output width (time) of the spectrogram + height (:obj:`int`): + Target output height (frequency) of the spectrogram + + Example: + >>> import torchsig.transforms as ST + >>> # Resize input spectrogram to (512,512) + >>> transform = ST.SpectrogramResize(width=512, height=512) + + """ + def __init__( + self, + width: int = 512, + height: int = 512, + ): + super(SpectrogramResize, self).__init__() + self.width = width + self.height = height + + def __call__(self, data: Any) -> Any: + spec_data = data.iq_data if isinstance(data, SignalData) else data + + # Next, perform the random cropping/padding + channels, curr_height, curr_width = spec_data.shape + pad_height, crop_height = False, False + pad_width, crop_width = False, False + pad_height_samps, pad_width_samps = 0, 0 + if curr_height < self.height: + pad_height = True + pad_height_samps = self.height - curr_height + elif curr_height > self.height: + crop_height = True + if curr_width < self.width: + pad_width = True + pad_width_samps = self.width - curr_width + elif curr_width > self.width: + crop_width = True + + if pad_height or pad_width: + def pad_func(vector, pad_width, iaxis, kwargs): + vector[:pad_width[0]] = np.random.rand(len(vector[:pad_width[0]]))*kwargs['pad_value'] + vector[-pad_width[1]:] = np.random.rand(len(vector[-pad_width[1]:]))*kwargs['pad_value'] + + if channels == 2: + new_data_real = np.pad( + spec_data[0], + ( + (pad_height_samps//2+1,pad_height_samps//2+1), + (pad_width_samps//2+1,pad_width_samps//2+1), + ), + pad_func, + pad_value = np.percentile(np.abs(spec_data[0]),50), + ) + new_data_imag = np.pad( + spec_data[1], + ( + (pad_height_samps//2+1,pad_height_samps//2+1), + (pad_width_samps//2+1,pad_width_samps//2+1), + ), + pad_func, + pad_value = np.percentile(np.abs(spec_data[1]),50), + ) + spec_data = np.concatenate( + [ + np.expand_dims(new_data_real,axis=0), + np.expand_dims(new_data_imag,axis=0) + ], + axis=0, + ) + else: + spec_data = np.pad( + spec_data, + ( + (pad_height_samps//2+1,pad_height_samps//2+1), + (pad_width_samps//2+1,pad_width_samps//2+1), + ), + pad_func, + min_value = np.percentile(np.abs(spec_data[0]),50), + ) + + spec_data = spec_data[:,:self.height,:self.width] + + # Update SignalData object if necessary, otherwise return + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=[], + ) + new_data.iq_data = spec_data + + # Update SignalDescription + new_signal_description = [] + signal_description = [data.signal_description] if isinstance(data.signal_description, SignalDescription) else data.signal_description + for signal_desc in signal_description: + new_signal_desc = deepcopy(signal_desc) + + # Check bounds for partial signals + new_signal_desc.lower_frequency = -0.5 if new_signal_desc.lower_frequency < -0.5 else new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + # Update labels based on padding/cropping + if pad_height: + new_signal_desc.lower_frequency = ((new_signal_desc.lower_frequency+0.5)*curr_height + pad_height_samps//2+1) / self.height - 0.5 + new_signal_desc.upper_frequency = ((new_signal_desc.upper_frequency+0.5)*curr_height + pad_height_samps//2+1) / self.height - 0.5 + new_signal_desc.center_frequency = ((new_signal_desc.center_frequency+0.5)*curr_height + pad_height_samps//2+1) / self.height - 0.5 + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + + if crop_height: + if (new_signal_desc.lower_frequency+0.5)*curr_height >= crop_height_start+self.height or \ + (new_signal_desc.upper_frequency+0.5)*curr_height <= crop_height_start: + continue + if (new_signal_desc.lower_frequency+0.5)*curr_height <= crop_height_start: + new_signal_desc.lower_frequency = -0.5 + else: + new_signal_desc.lower_frequency = ((new_signal_desc.lower_frequency+0.5)*curr_height) / self.height - 0.5 + if (new_signal_desc.upper_frequency+0.5)*curr_height >= crop_height_start+self.height: + new_signal_desc.upper_frequency = crop_height_start+self.height + else: + new_signal_desc.upper_frequency = ((new_signal_desc.upper_frequency+0.5)*curr_height) / self.height - 0.5 + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth / 2 + + if pad_width: + new_signal_desc.start = (new_signal_desc.start * curr_width + pad_width_samps//2+1) / self.width + new_signal_desc.stop = (new_signal_desc.stop * curr_width + pad_width_samps//2+1) / self.width + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + if crop_width: + if new_signal_desc.start*curr_width <= 0: + new_signal_desc.start = 0.0 + elif new_signal_desc.start*curr_width >= self.width: + continue + else: + new_signal_desc.start = (new_signal_desc.start * curr_width) / self.width + if new_signal_desc.stop*curr_width >= self.width: + new_signal_desc.stop = 1.0 + elif new_signal_desc.stop*curr_width <= 0: + continue + else: + new_signal_desc.stop = (new_signal_desc.stop * curr_width) / self.width + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + # Append SignalDescription to list + new_signal_description.append(new_signal_desc) + + new_data.signal_description = new_signal_description + + else: + new_data = spec_data + + return new_data + + +class SpectrogramDropSamples(SignalTransform): + """Randomly drop samples from the input data of specified durations and + with specified fill techniques: + * `ffill` (front fill): replace drop samples with the last previous value + * `bfill` (back fill): replace drop samples with the next value + * `mean`: replace drop samples with the mean value of the full data + * `zero`: replace drop samples with zeros + * `low`: replace drop samples with low power samples + * `min`: replace drop samples with the minimum of the absolute power + * `max`: replace drop samples with the maximum of the absolute power + * `ones`: replace drop samples with ones + + Transform is based off of the + `TSAug Dropout Transform `_. + + Args: + drop_rate (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + drop_rate sets the rate at which to drop samples + * If Callable, produces a sample by calling drop_rate() + * If int or float, drop_rate is fixed at the value provided + * If list, drop_rate is any element in the list + * If tuple, drop_rate is in range of (tuple[0], tuple[1]) + + size (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + size sets the size of each instance of dropped samples + * If Callable, produces a sample by calling size() + * If int or float, size is fixed at the value provided + * If list, size is any element in the list + * If tuple, size is in range of (tuple[0], tuple[1]) + + fill (:py:class:`~Callable`, :obj:`list`, :obj:`str`): + fill sets the method of how the dropped samples should be filled + * If Callable, produces a sample by calling fill() + * If list, fill is any element in the list + * If str, fill is fixed at the method provided + + """ + def __init__( + self, + drop_rate: NumericParameter = uniform_continuous_distribution(0.001,0.005), + size: NumericParameter = uniform_discrete_distribution(np.arange(1,10)), + fill: Union[List, str] = uniform_discrete_distribution(["ffill", "bfill", "mean", "zero", "low", "min", "max", "ones"]), + ): + super(SpectrogramDropSamples, self).__init__() + self.drop_rate = to_distribution(drop_rate, self.random_generator) + self.size = to_distribution(size, self.random_generator) + self.fill = to_distribution(fill, self.random_generator) + + def __call__(self, data: Any) -> Any: + drop_rate = self.drop_rate() + fill = self.fill() + + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.float64), + signal_description=data.signal_description, + ) + + # Perform data augmentation + channels, height, width = data.iq_data.shape + spec_size = height * width + drop_instances = int(spec_size * drop_rate) + drop_sizes = self.size(drop_instances).astype(int) + drop_starts = np.random.uniform(1, spec_size-max(drop_sizes)-1, drop_instances).astype(int) + + new_data.iq_data = functional.drop_spec_samples(data.iq_data, drop_starts, drop_sizes, fill) + + else: + drop_instances = int(data.shape[0] * drop_rate) + drop_sizes = self.size(drop_instances).astype(int) + drop_starts = np.random.uniform(0, data.shape[0]-max(drop_sizes), drop_instances).astype(int) + + new_data = functional.drop_spec_samples(data, drop_starts, drop_sizes, fill) + return new_data + + +class SpectrogramPatchShuffle(SignalTransform): + """Randomly shuffle multiple local regions of samples. + + Transform is loosely based on + `PatchShuffle Regularization `_. + + Args: + patch_size (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + patch_size sets the size of each patch to shuffle + * If Callable, produces a sample by calling patch_size() + * If int or float, patch_size is fixed at the value provided + * If list, patch_size is any element in the list + * If tuple, patch_size is in range of (tuple[0], tuple[1]) + + shuffle_ratio (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + shuffle_ratio sets the ratio of the patches to shuffle + * If Callable, produces a sample by calling shuffle_ratio() + * If int or float, shuffle_ratio is fixed at the value provided + * If list, shuffle_ratio is any element in the list + * If tuple, shuffle_ratio is in range of (tuple[0], tuple[1]) + + """ + def __init__( + self, + patch_size: NumericParameter = uniform_continuous_distribution(2,16), + shuffle_ratio: FloatParameter = uniform_continuous_distribution(0.01,0.10), + ): + super(SpectrogramPatchShuffle, self).__init__() + self.patch_size = to_distribution(patch_size, self.random_generator) + self.shuffle_ratio = to_distribution(shuffle_ratio, self.random_generator) + + def __call__(self, data: Any) -> Any: + patch_size = int(self.patch_size()) + shuffle_ratio = self.shuffle_ratio() + + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=data.signal_description, + ) + + # Perform data augmentation + new_data.iq_data = functional.spec_patch_shuffle(data.iq_data, patch_size, shuffle_ratio) + else: + new_data = functional.spec_patch_shuffle(data, patch_size, shuffle_ratio) + return new_data + + +class SpectrogramTranslation(SignalTransform): + """Transform that inputs a spectrogram and applies a random time/freq + translation + + Args: + time_shift (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + time_shift sets the translation along the time-axis + * If Callable, produces a sample by calling time_shift() + * If int, time_shift is fixed at the value provided + * If list, time_shift is any element in the list + * If tuple, time_shift is in range of (tuple[0], tuple[1]) + + freq_shift (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + freq_shift sets the translation along the freq-axis + * If Callable, produces a sample by calling freq_shift() + * If int, freq_shift is fixed at the value provided + * If list, freq_shift is any element in the list + * If tuple, freq_shift is in range of (tuple[0], tuple[1]) + + """ + def __init__( + self, + time_shift: IntParameter = uniform_continuous_distribution(-128,128), + freq_shift: IntParameter = uniform_continuous_distribution(-128,128), + ): + super(SpectrogramTranslation, self).__init__() + self.time_shift = to_distribution(time_shift, self.random_generator) + self.freq_shift = to_distribution(freq_shift, self.random_generator) + + def __call__(self, data: Any) -> Any: + time_shift = int(self.time_shift()) + freq_shift = int(self.freq_shift()) + + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=data.signal_description, + ) + + new_data.iq_data = functional.spec_translate(data.iq_data, time_shift, freq_shift) + + # Update SignalDescription + new_signal_description = [] + signal_description = [data.signal_description] if isinstance(data.signal_description, SignalDescription) else data.signal_description + for signal_desc in signal_description: + new_signal_desc = deepcopy(signal_desc) + + # Update time fields + new_signal_desc.start = new_signal_desc.start + time_shift / new_data.iq_data.shape[1] + new_signal_desc.stop = new_signal_desc.stop + time_shift / new_data.iq_data.shape[1] + if new_signal_desc.start >= 1.0 or new_signal_desc.stop <= 0.0: + continue + new_signal_desc.start = 0.0 if new_signal_desc.start < 0.0 else new_signal_desc.start + new_signal_desc.stop = 1.0 if new_signal_desc.stop > 1.0 else new_signal_desc.stop + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + # Trim any out-of-capture freq values + new_signal_desc.lower_frequency = -0.5 if new_signal_desc.lower_frequency < -0.5 else new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + + # Update freq fields + new_signal_desc.lower_frequency = new_signal_desc.lower_frequency + freq_shift / new_data.iq_data.shape[2] + new_signal_desc.upper_frequency = new_signal_desc.upper_frequency + freq_shift / new_data.iq_data.shape[2] + if new_signal_desc.lower_frequency >= 0.5 or new_signal_desc.upper_frequency <= -0.5: + continue + new_signal_desc.lower_frequency = -0.5 if new_signal_desc.lower_frequency < -0.5 else new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + # Append SignalDescription to list + new_signal_description.append(new_signal_desc) + + # Set output data's SignalDescription to above list + new_data.signal_description = new_signal_description + + else: + new_data = functional.spec_translate(data, time_shift, freq_shift) + return new_data + + +class SpectrogramMosaicCrop(SignalTransform): + """The SpectrogramMosaicCrop transform takes the original input tensor and + inserts it randomly into one cell of a 2x2 grid of 2x the size of the + orginal spectrogram input. The `dataset` argument is then read 3x to + retrieve spectrograms to fill the remaining cells of the 2x2 grid. Finally, + the 2x larger stitched view of 4x spectrograms is randomly cropped to the + original target size, containing pieces of each of the 4x stitched + spectrograms. + + Args: + dataset :obj:`SignalDataset`: + An SignalDataset of complex-valued examples to be used as a source for + the mosaic operation + + """ + def __init__(self, dataset: SignalDataset = None): + super(SpectrogramMosaicCrop, self).__init__() + self.dataset = dataset + + def __call__(self, data: Any) -> Any: + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=data.signal_description, + ) + + # Read shapes + channels, height, width = data.iq_data.shape + + # Randomly decide the new x0, y0 point of the stitched images + x0 = np.random.randint(0,width) + y0 = np.random.randint(0,height) + + # Initialize new SignalDescription object + new_signal_description = [] + + # First, create a 2x2 grid of (512+512,512+512) and randomly put the initial data into a grid cell + cell_idx = np.random.randint(0,4) + x_idx = 0 if cell_idx == 0 or cell_idx == 2 else 1 + y_idx = 0 if cell_idx == 0 or cell_idx == 1 else 1 + full_mosaic = np.empty( + (channels, height*2, width*2), + dtype=data.iq_data.dtype, + ) + full_mosaic[:,y_idx*height:(y_idx+1)*height,x_idx*width:(x_idx+1)*width] = data.iq_data + + # Update original data's SignalDescription objects given the cell index + signal_description = [data.signal_description] if isinstance(data.signal_description, SignalDescription) else data.signal_description + for signal_desc in signal_description: + new_signal_desc = deepcopy(signal_desc) + + # Update time fields + if x_idx == 0: + if new_signal_desc.stop * width < x0: + continue + new_signal_desc.start = 0 if new_signal_desc.start < (x0 / width) else new_signal_desc.start - (x0 / width) + new_signal_desc.stop = new_signal_desc.stop - (x0 / width) if new_signal_desc.stop < 1.0 else 1.0 - (x0 / width) + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + else: + if new_signal_desc.start * width > x0: + continue + new_signal_desc.start = (width - x0) / width + new_signal_desc.start + new_signal_desc.stop = (width - x0) / width + new_signal_desc.stop + new_signal_desc.stop = 1.0 if new_signal_desc.stop > 1.0 else new_signal_desc.stop + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + # Update frequency fields + new_signal_desc.lower_frequency = -0.5 if new_signal_desc.lower_frequency < -0.5 else new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + if y_idx == 0: + if (new_signal_desc.upper_frequency+0.5) * height < y0: + continue + new_signal_desc.lower_frequency = -0.5 if (new_signal_desc.lower_frequency+0.5) < (y0 / height) else new_signal_desc.lower_frequency - (y0 / height) + new_signal_desc.upper_frequency = new_signal_desc.upper_frequency - (y0 / height) if new_signal_desc.upper_frequency < 0.5 else 0.5 - (y0 / height) + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + else: + if (new_signal_desc.lower_frequency+0.5) * height > y0: + continue + new_signal_desc.lower_frequency = (height - y0) / height + new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = (height - y0) / height + new_signal_desc.upper_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + # Append SignalDescription to list + new_signal_description.append(new_signal_desc) + + # Next, fill in the remaining cells with data randomly sampled from the input dataset + for cell_i in range(4): + if cell_i == cell_idx: + # Skip if the original data's cell + continue + x_idx = 0 if cell_i == 0 or cell_i == 2 else 1 + y_idx = 0 if cell_i == 0 or cell_i == 1 else 1 + dataset_idx = np.random.randint(len(self.dataset)) + curr_data, curr_signal_desc = self.dataset[dataset_idx] + full_mosaic[:,y_idx*height:(y_idx+1)*height,x_idx*width:(x_idx+1)*width] = curr_data + + # Update inserted data's SignalDescription objects given the cell index + signal_description = [curr_signal_desc] if isinstance(curr_signal_desc, SignalDescription) else curr_signal_desc + for signal_desc in signal_description: + new_signal_desc = deepcopy(signal_desc) + + # Update time fields + if x_idx == 0: + if new_signal_desc.stop * width < x0: + continue + new_signal_desc.start = 0 if new_signal_desc.start < (x0 / width) else new_signal_desc.start - (x0 / width) + new_signal_desc.stop = new_signal_desc.stop - (x0 / width) if new_signal_desc.stop < 1.0 else 1.0 - (x0 / width) + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + else: + if new_signal_desc.start * width > x0: + continue + new_signal_desc.start = (width - x0) / width + new_signal_desc.start + new_signal_desc.stop = (width - x0) / width + new_signal_desc.stop + new_signal_desc.stop = 1.0 if new_signal_desc.stop > 1.0 else new_signal_desc.stop + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + # Update frequency fields + new_signal_desc.lower_frequency = -0.5 if new_signal_desc.lower_frequency < -0.5 else new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + if y_idx == 0: + if (new_signal_desc.upper_frequency+0.5) * height < y0: + continue + new_signal_desc.lower_frequency = -0.5 if (new_signal_desc.lower_frequency+0.5) < (y0 / height) else new_signal_desc.lower_frequency - (y0 / height) + new_signal_desc.upper_frequency = new_signal_desc.upper_frequency - (y0 / height) if new_signal_desc.upper_frequency < 0.5 else 0.5 - (y0 / height) + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + else: + if (new_signal_desc.lower_frequency+0.5) * height > y0: + continue + new_signal_desc.lower_frequency = (height - y0) / height + new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = (height - y0) / height + new_signal_desc.upper_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + # Append SignalDescription to list + new_signal_description.append(new_signal_desc) + + # After the data has been stitched into the large 2x2 gride, crop using x0, y0 + new_data.iq_data = full_mosaic[:,y0:y0+height,x0:x0+width] + + # Set output data's SignalDescription to above list + new_data.signal_description = new_signal_description + + else: + # Read shapes + channels, height, width = data.shape + + # Randomly decide the new x0, y0 point of the stitched images + x0 = np.random.randint(0,width) + y0 = np.random.randint(0,height) + + # Initialize new SignalDescription object + new_signal_description = [] + + # First, create a 2x2 grid of (512+512,512+512) and randomly put the initial data into a grid cell + cell_idx = np.random.randint(0,4) + x_idx = 0 if cell_idx == 0 or cell_idx == 2 else 1 + y_idx = 0 if cell_idx == 0 or cell_idx == 1 else 1 + full_mosaic = np.empty( + (channels, height*2, width*2), + dtype=data.dtype, + ) + full_mosaic[:,y_idx*height:(y_idx+1)*height,x_idx*width:(x_idx+1)*width] = data + + # Next, fill in the remaining cells with data randomly sampled from the input dataset + for cell_i in range(4): + if cell_i == cell_idx: + # Skip if the original data's cell + continue + x_idx = 0 if cell_i == 0 or cell_i == 2 else 1 + y_idx = 0 if cell_i == 0 or cell_i == 1 else 1 + dataset_idx = np.random.randint(len(self.dataset)) + curr_data, curr_signal_desc = self.dataset[dataset_idx] + full_mosaic[:,y_idx*height:(y_idx+1)*height,x_idx*width:(x_idx+1)*width] = curr_data + + # After the data has been stitched into the large 2x2 gride, crop using x0, y0 + new_data = full_mosaic[:,y0:y0+height,x0:x0+width] + + return new_data + + +class SpectrogramMosaicDownsample(SignalTransform): + """The SpectrogramMosaicDownsample transform takes the original input + tensor and inserts it randomly into one cell of a 2x2 grid of 2x the size + of the orginal spectrogram input. The `dataset` argument is then read 3x to + retrieve spectrograms to fill the remaining cells of the 2x2 grid. Finally, + the 2x oversized stitched spectrograms are downsampled by 2 to become the + desired, original shape + + Args: + dataset :obj:`SignalDataset`: + An SignalDataset of complex-valued examples to be used as a source for + the mosaic operation + + """ + def __init__(self, dataset: SignalDataset = None): + super(SpectrogramMosaicDownsample, self).__init__() + self.dataset = dataset + + def __call__(self, data: Any) -> Any: + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=data.signal_description, + ) + + # Read shapes + channels, height, width = data.iq_data.shape + + # Initialize new SignalDescription object + new_signal_description = [] + + # First, create a 2x2 grid of (512+512,512+512) and randomly put the initial data into a grid cell + cell_idx = np.random.randint(0,4) + x_idx = 0 if cell_idx == 0 or cell_idx == 2 else 1 + y_idx = 0 if cell_idx == 0 or cell_idx == 1 else 1 + full_mosaic = np.empty( + (channels, height*2, width*2), + dtype=data.iq_data.dtype, + ) + full_mosaic[:,y_idx*height:(y_idx+1)*height,x_idx*width:(x_idx+1)*width] = data.iq_data + + # Update original data's SignalDescription objects given the cell index + signal_description = [data.signal_description] if isinstance(data.signal_description, SignalDescription) else data.signal_description + for signal_desc in signal_description: + new_signal_desc = deepcopy(signal_desc) + + # Update time fields + if x_idx == 0: + new_signal_desc.start /= 2 + new_signal_desc.stop /= 2 + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + else: + new_signal_desc.start = new_signal_desc.start / 2 + 0.5 + new_signal_desc.stop = new_signal_desc.stop / 2 + 0.5 + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + # Update frequency fields + new_signal_desc.lower_frequency = -0.5 if new_signal_desc.lower_frequency < -0.5 else new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + if y_idx == 0: + new_signal_desc.lower_frequency = (new_signal_desc.lower_frequency+0.5) / 2 - 0.5 + new_signal_desc.upper_frequency = (new_signal_desc.upper_frequency+0.5) / 2 - 0.5 + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + else: + new_signal_desc.lower_frequency = (new_signal_desc.lower_frequency+0.5) / 2 + new_signal_desc.upper_frequency = (new_signal_desc.upper_frequency+0.5) / 2 + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + # Append SignalDescription to list + new_signal_description.append(new_signal_desc) + + # Next, fill in the remaining cells with data randomly sampled from the input dataset + for cell_i in range(4): + if cell_i == cell_idx: + # Skip if the original data's cell + continue + x_idx = 0 if cell_i == 0 or cell_i == 2 else 1 + y_idx = 0 if cell_i == 0 or cell_i == 1 else 1 + dataset_idx = np.random.randint(len(self.dataset)) + curr_data, curr_signal_desc = self.dataset[dataset_idx] + full_mosaic[:,y_idx*height:(y_idx+1)*height,x_idx*width:(x_idx+1)*width] = curr_data + + # Update inserted data's SignalDescription objects given the cell index + signal_description = [curr_signal_desc] if isinstance(curr_signal_desc, SignalDescription) else curr_signal_desc + for signal_desc in signal_description: + new_signal_desc = deepcopy(signal_desc) + + # Update time fields + if x_idx == 0: + new_signal_desc.start /= 2 + new_signal_desc.stop /= 2 + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + else: + new_signal_desc.start = new_signal_desc.start / 2 + 0.5 + new_signal_desc.stop = new_signal_desc.stop / 2 + 0.5 + new_signal_desc.duration = new_signal_desc.stop - new_signal_desc.start + + # Update frequency fields + new_signal_desc.lower_frequency = -0.5 if new_signal_desc.lower_frequency < -0.5 else new_signal_desc.lower_frequency + new_signal_desc.upper_frequency = 0.5 if new_signal_desc.upper_frequency > 0.5 else new_signal_desc.upper_frequency + if y_idx == 0: + new_signal_desc.lower_frequency = (new_signal_desc.lower_frequency+0.5) / 2 - 0.5 + new_signal_desc.upper_frequency = (new_signal_desc.upper_frequency+0.5) / 2 - 0.5 + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + else: + new_signal_desc.lower_frequency = (new_signal_desc.lower_frequency+0.5) / 2 + new_signal_desc.upper_frequency = (new_signal_desc.upper_frequency+0.5) / 2 + new_signal_desc.bandwidth = new_signal_desc.upper_frequency - new_signal_desc.lower_frequency + new_signal_desc.center_frequency = new_signal_desc.lower_frequency + new_signal_desc.bandwidth * 0.5 + + # Append SignalDescription to list + new_signal_description.append(new_signal_desc) + + # After the data has been stitched into the large 2x2 gride, downsample by 2 + new_data.iq_data = full_mosaic[:,::2,::2] + + # Set output data's SignalDescription to above list + new_data.signal_description = new_signal_description + + else: + # Read shapes + channels, height, width = data.shape + + # Initialize new SignalDescription object + new_signal_description = [] + + # First, create a 2x2 grid of (512+512,512+512) and randomly put the initial data into a grid cell + cell_idx = np.random.randint(0,4) + x_idx = 0 if cell_idx == 0 or cell_idx == 2 else 1 + y_idx = 0 if cell_idx == 0 or cell_idx == 1 else 1 + full_mosaic = np.empty( + (channels, height*2, width*2), + dtype=data.dtype, + ) + full_mosaic[:,y_idx*height:(y_idx+1)*height,x_idx*width:(x_idx+1)*width] = data + + # Next, fill in the remaining cells with data randomly sampled from the input dataset + for cell_i in range(4): + if cell_i == cell_idx: + # Skip if the original data's cell + continue + x_idx = 0 if cell_i == 0 or cell_i == 2 else 1 + y_idx = 0 if cell_i == 0 or cell_i == 1 else 1 + dataset_idx = np.random.randint(len(self.dataset)) + curr_data, curr_signal_desc = self.dataset[dataset_idx] + full_mosaic[:,y_idx*height:(y_idx+1)*height,x_idx*width:(x_idx+1)*width] = curr_data + + # After the data has been stitched into the large 2x2 gride, downsample by 2 + new_data = full_mosaic[:,::2,::2] + + return new_data diff --git a/torchsig/transforms/system_impairment/__init__.py b/torchsig/transforms/system_impairment/__init__.py index fc6988b..1b81242 100644 --- a/torchsig/transforms/system_impairment/__init__.py +++ b/torchsig/transforms/system_impairment/__init__.py @@ -1,2 +1,2 @@ from .si import * -from .si_functional import * +from .functional import * diff --git a/torchsig/transforms/system_impairment/functional.py b/torchsig/transforms/system_impairment/functional.py new file mode 100644 index 0000000..e9ea04d --- /dev/null +++ b/torchsig/transforms/system_impairment/functional.py @@ -0,0 +1,635 @@ +import numpy as np +from scipy import signal as sp +from numba import njit, int64, float64, complex64 + + +def time_shift( + tensor: np.ndarray, + t_shift: float +) -> np.ndarray: + """Shifts tensor in the time dimension by tshift samples. Zero-padding is applied to maintain input size. + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor to be shifted. + + t_shift (:obj:`int` or :class:`numpy.ndarray`): + Number of samples to shift right or left (if negative) + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor shifted in time of size tensor.shape + """ + # Valid Range Error Checking + if np.max(np.abs(t_shift)) >= tensor.shape[0]: + return np.zeros_like(tensor, dtype=np.complex64) + + # This overwrites tensor as side effect, modifies inplace + if t_shift > 0: + tmp = tensor[:-t_shift] # I'm sure there's a more compact way. + tensor = np.pad(tmp, (t_shift, 0), 'constant', constant_values=0 + 0j) + elif t_shift < 0: + tmp = tensor[-t_shift:] # I'm sure there's a more compact way. + tensor = np.pad(tmp, (0, -t_shift), 'constant', constant_values=0 + 0j) + return tensor + + +def time_crop( + tensor: np.ndarray, + start: int, + length: int +) -> np.ndarray: + """Crops a tensor in the time dimension from index start(inclusive) for length samples. + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor to be cropped. + + start (:obj:`int` or :class:`numpy.ndarray`): + index to begin cropping + + length (:obj:`int`): + number of samples to include + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor cropped in time of size (tensor.shape[0], length) + """ + # Type and Size checking + if length < 0: + raise ValueError('Length must be greater than 0') + + if np.any(start < 0): + raise ValueError('Start must be greater than 0') + + if np.max(start) >= tensor.shape[0] or length == 0: + return np.empty(shape=(1, 1)) + + crop_len = min(length, tensor.shape[0] - np.max(start)) + + return tensor[start:start + crop_len] + + +def freq_shift(tensor: np.ndarray, f_shift: float) -> np.ndarray: + """Shifts each tensor in freq by freq_shift along the time dimension + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor to be frequency-shifted. + + f_shift (:obj:`float` or :class:`numpy.ndarray`): + Frequency shift relative to the sample rate in range [-.5, .5] + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has been frequency shifted along time dimension of size tensor.shape + """ + sinusoid = np.exp(2j * np.pi * f_shift * np.arange(tensor.shape[0], dtype=np.float64)) + return np.multiply(tensor, np.asarray(sinusoid)) + + +def freq_shift_avoid_aliasing(tensor: np.ndarray, f_shift: float) -> np.ndarray: + """Similar to `freq_shift` function but performs the frequency shifting at + a higher sample rate with filtering to avoid aliasing + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor to be frequency-shifted. + + f_shift (:obj:`float` or :class:`numpy.ndarray`): + Frequency shift relative to the sample rate in range [-.5, .5] + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has been frequency shifted along time dimension of size tensor.shape + """ + # Match output size to input + num_iq_samples = tensor.shape[0] + + # Interpolate up to avoid frequency wrap around during shift + up = 2 + down = 1 + tensor = sp.resample_poly(tensor, up, down) + + # Filter around center to remove original alias effects + num_taps = int(2*np.ceil(50*2*np.pi/(1/up)/.125/22)) # fred harris rule of thumb * 2 + taps = sp.firwin( + num_taps, + (1/up), + width=(1/up) * .02, + window=sp.get_window("blackman", num_taps), + scale=True + ) + tensor = sp.fftconvolve(tensor, taps, mode="same") + + # Freq shift to desired center freq + time_vector = np.arange(tensor.shape[0], dtype=np.float) + tensor = tensor * np.exp(2j * np.pi * f_shift / up * time_vector) + + # Filter to remove out-of-band regions + num_taps = int(2 * np.ceil(50 * 2 * np.pi / (1/up) / .125 / 22)) # fred harris rule-of-thumb * 2 + taps = sp.firwin( + num_taps, + 1 / up, + width=(1/up) * .02, + window=sp.get_window("blackman", num_taps), + scale=True + ) + tensor = sp.fftconvolve(tensor, taps, mode="same") + tensor = tensor[:int(num_iq_samples*up)] # prune to be correct size out of filter + + # Decimate back down to correct sample rate + tensor = sp.resample_poly(tensor, down, up) + + return tensor[:num_iq_samples] + + +@njit(cache=False) +def _fractional_shift_helper( + taps: np.ndarray, + raw_iq: np.ndarray, + stride: int, + offset: int +): + """Fractional shift. First, we up-sample by a large, fixed amount. Filter with 1/upsample_rate/2.0, + Next we down-sample by the same, large fixed amount with a chosen offset. Doing this efficiently means not actually zero-padding. + + The efficient way to do this is to decimate the taps and filter the signal with some offset in the taps. + """ + # We purposely do not calculate values within the group delay. + group_delay = ((taps.shape[0] - 1) // 2 - (stride - 1)) // stride + 1 + if offset < 0: + offset += stride + group_delay -= 1 + + # Decimate the taps. + taps = taps[offset::stride] + + # Determine output size + num_taps = taps.shape[0] + num_raw_iq = raw_iq.shape[0] + output = np.zeros(((num_taps + num_raw_iq - 1 - group_delay),), dtype=np.complex128) + + # This is a just convolution of taps and raw_iq + for o_idx in range(output.shape[0]): + idx_mn = o_idx - (num_raw_iq - 1) if o_idx >= num_raw_iq - 1 else 0 + idx_mx = o_idx if o_idx < num_taps - 1 else num_taps - 1 + for f_idx in range(idx_mn, idx_mx): + output[o_idx - group_delay] += taps[f_idx] * raw_iq[o_idx - f_idx] + return output + + +def fractional_shift( + tensor: np.ndarray, + taps: np.ndarray, + stride: int, + delay: int +) -> np.ndarray: + """Applies fractional sample delay of delay using a polyphase interpolator + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor to be shifted in time. + + taps (:obj:`float` or :class:`numpy.ndarray`): + taps to use for filtering + + stride (:obj:`int`): + interpolation rate of internal filter + + delay (:obj:`int` ): + Delay in number of samples in [-1, 1] + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has been fractionally-shifted along time dimension of size tensor.shape + """ + real_part = _fractional_shift_helper(taps, tensor.real, stride, int(stride * float(delay))) + imag_part = _fractional_shift_helper(taps, tensor.imag, stride, int(stride * float(delay))) + tensor = real_part[:tensor.shape[0]] + 1j * imag_part[:tensor.shape[0]] + zero_idx = -1 if delay < 0 else 0 # do not extrapolate, zero-pad. + tensor[zero_idx] = 0 + return tensor + + +def iq_imbalance( + tensor: np.ndarray, + iq_amplitude_imbalance_db: float, + iq_phase_imbalance: float, + iq_dc_offset_db: float +) -> np.ndarray: + """Applies IQ imbalance to tensor + + Args: + tensor (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor to be shifted in time. + + iq_amplitude_imbalance_db (:obj:`float` or :class:`numpy.ndarray`): + IQ amplitude imbalance in dB + + iq_phase_imbalance (:obj:`float` or :class:`numpy.ndarray`): + IQ phase imbalance in radians [-pi, pi] + + iq_dc_offset_db (:obj:`float` or :class:`numpy.ndarray`): + IQ DC Offset in dB + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has an IQ imbalance applied across the time dimension of size tensor.shape + """ + # amplitude imbalance + tensor = 10 ** (iq_amplitude_imbalance_db / 10.0) * np.real(tensor) + \ + 1j * 10 ** (iq_amplitude_imbalance_db / 10.0) * np.imag(tensor) + + # phase imbalance + tensor = np.exp(-1j * iq_phase_imbalance / 2.0) * np.real(tensor) + \ + np.exp(1j * (np.pi / 2.0 + iq_phase_imbalance / 2.0)) * np.imag(tensor) + + tensor += 10 ** (iq_dc_offset_db / 10.0) * np.real(tensor) + \ + 1j * 10 ** (iq_dc_offset_db / 10.0) * np.imag(tensor) + return tensor + + +def spectral_inversion(tensor: np.ndarray) -> np.ndarray: + """Applies a spectral inversion + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone a spectral inversion + + """ + tensor.imag *= -1 + return tensor + + +def channel_swap(tensor: np.ndarray) -> np.ndarray: + """Swap the I and Q channels of input complex data + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone channel swapping + + """ + real_component = tensor.real + imag_component = tensor.imag + new_tensor = np.empty(*tensor.shape, dtype=tensor.dtype) + new_tensor.real = imag_component + new_tensor.imag = real_component + return new_tensor + + +def time_reversal(tensor: np.ndarray) -> np.ndarray: + """Applies a time reversal to the input tensor + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone a time reversal + + """ + return np.flip(tensor, axis=0) + + +def amplitude_reversal(tensor: np.ndarray) -> np.ndarray: + """Applies an amplitude reversal to the input tensor by multiplying by -1 + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone an amplitude reversal + + """ + return tensor*-1 + + +def roll_off( + tensor: np.ndarray, + lowercutfreq: float, + uppercutfreq: float, + fltorder: int, +) -> np.ndarray: + """Applies front-end filter to tensor. Rolls off lower/upper edges of bandwidth + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + lowercutfreq (:obj:`float`): + lower bandwidth cut-off to begin linear roll-off + + uppercutfreq (:obj:`float`): + upper bandwidth cut-off to begin linear roll-off + + fltorder (:obj:`int`): + order of each FIR filter to be applied + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone front-end filtering. + + """ + if (lowercutfreq == 0) & (uppercutfreq == 1): + return tensor + elif uppercutfreq == 1: + if fltorder % 2 == 0: + fltorder += 1 + bandwidth = uppercutfreq - lowercutfreq + center_freq = lowercutfreq - 0.5 + bandwidth/2 + num_taps = fltorder + sinusoid = np.exp(2j * np.pi * center_freq * np.linspace(0, num_taps - 1, num_taps)) + taps = sp.firwin( + num_taps, + bandwidth, + width=bandwidth * .02, + window=sp.get_window("blackman", num_taps), + scale=True + ) + taps = taps * sinusoid + return sp.fftconvolve(tensor, taps, mode="same") + + +def add_slope(tensor: np.ndarray) -> np.ndarray: + """The slope between each sample and its preceeding sample is added to + every sample + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor with added noise. + """ + slope = np.diff(tensor) + slope = np.insert(slope, 0, 0) + return tensor + slope + + +def mag_rescale( + tensor: np.ndarray, + start: float, + scale: float, +) -> np.ndarray: + """Apply a rescaling of input `scale` starting at time `start` + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + start (:obj:`float`): + Normalized start time of rescaling + + scale (:obj:`float`): + Scaling factor + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone rescaling + + """ + start = int(tensor.shape[0] * start) + tensor[start:] *= scale + return tensor + + +def drop_samples( + tensor: np.ndarray, + drop_starts: np.ndarray, + drop_sizes: np.ndarray, + fill: str, +) -> np.ndarray: + """Drop samples at specified input locations/durations with fill technique + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + drop_starts (:class:`numpy.ndarray`): + Indices of where drops start + + drop_sizes (:class:`numpy.ndarray`): + Durations of each drop instance + + fill (:obj:`str`): + String specifying how the dropped samples should be replaced + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone the dropped samples + + """ + for idx, drop_start in enumerate(drop_starts): + if fill == "ffill": + drop_region = np.ones(drop_sizes[idx], dtype=np.complex64)*tensor[drop_start-1] + elif fill == "bfill": + drop_region = np.ones(drop_sizes[idx], dtype=np.complex64)*tensor[drop_start+drop_sizes[idx]] + elif fill == "mean": + drop_region = np.ones(drop_sizes[idx], dtype=np.complex64)*np.mean(tensor) + elif fill == "zero": + drop_region = np.zeros(drop_sizes[idx], dtype=np.complex64) + else: + raise ValueError("fill expects ffill, bfill, mean, or zero. Found {}".format(fill)) + + # Update drop region + tensor[drop_start:drop_start+drop_sizes[idx]] = drop_region + + return tensor + + +def quantize( + tensor: np.ndarray, + num_levels: int, + round_type: str = 'floor', +) -> np.ndarray: + """Quantize the input to the number of levels specified + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + num_levels (:obj:`int`): + Number of quantization levels + + round_type (:obj:`str`): + Quantization rounding. Options: 'floor', 'middle', 'ceiling' + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone quantization + + """ + # Setup quantization resolution/bins + max_value = max(np.abs(tensor)) + 1e-9 + bins = np.linspace(-max_value,max_value,num_levels+1) + + # Digitize to bins + quantized_real = np.digitize(tensor.real, bins) + quantized_imag = np.digitize(tensor.imag, bins) + + if round_type == 'floor': + quantized_real -= 1 + quantized_imag -= 1 + + # Revert to values + quantized_real = bins[quantized_real] + quantized_imag = bins[quantized_imag] + + if round_type == 'nearest': + bin_size = np.diff(bins)[0] + quantized_real -= (bin_size/2) + quantized_imag -= (bin_size/2) + + quantized_tensor = quantized_real + 1j*quantized_imag + + return quantized_tensor + + +def clip(tensor: np.ndarray, clip_percentage: float) -> np.ndarray: + """Clips input tensor's values above/below a specified percentage of the + max/min of the input tensor + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + clip_percentage (:obj:`float`): + Percentage of max/min values to clip + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor with added noise. + """ + real_tensor = tensor.real + max_val = np.max(real_tensor) * clip_percentage + min_val = np.min(real_tensor) * clip_percentage + real_tensor[real_tensor>max_val] = max_val + real_tensor[real_tensormax_val] = max_val + imag_tensor[imag_tensor np.ndarray: + """Create a complex-valued filter with `num_taps` number of taps, convolve + the random filter with the input data, and sum the original data with the + randomly-filtered data using an `alpha` weighting factor. + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + num_taps: (:obj:`int`): + Number of taps in random filter + + alpha: (:obj:`float`): + Weighting for the summation between the original data and the + randomly-filtered data, following: + + `output = (1 - alpha) * tensor + alpha * filtered_tensor` + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor with weighted random filtering + + """ + filter_taps = np.random.rand(num_taps)+1j*np.random.rand(num_taps) + return (1 - alpha) * tensor + alpha * np.convolve(tensor, filter_taps, mode='same') + + +@njit(complex64[:](complex64[:], float64, float64, float64, float64, float64, float64, float64, float64, float64), cache=False) +def agc( + tensor: np.ndarray, + initial_gain_db: float, + alpha_smooth: float, + alpha_track: float, + alpha_overflow: float, + alpha_acquire: float, + ref_level_db: float, + track_range_db: float, + low_level_db: float, + high_level_db: float, +) -> np.ndarray: + """AGC implementation + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor to be agc'd + + initial_gain_db (:obj:`float`): + Initial gain value in linear units + + alpha_smooth (:obj:`float`): + Alpha for averaging the measured signal level level_n = level_n*alpha + level_n-1*(1 - alpha) + + alpha_track (:obj:`float`): + Amount by which to adjust gain when in tracking state + + alpha_overflow (:obj:`float`): + Amount by which to adjust gain when in overflow state [level_db + gain_db] >= max_level + + alpha_acquire (:obj:`float`): + Amount by which to adjust gain when in acquire state abs([ref_level_db - level_db - gain_db]) >= track_range_db + + ref_level_db (:obj:`float`): + Level to which we intend to adjust gain to achieve + + track_range_db (:obj:`float`): + Range from ref_level_linear for which we can deviate before going into acquire state + + low_level_db (:obj:`float`): + Level below which we disable AGC + + high_level_db (:obj:`float`): + Level above which we go into overflow state + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor with AGC applied + + """ + output = np.zeros_like(tensor) + gain_db = initial_gain_db + for sample_idx, sample in enumerate(tensor): + if np.abs(sample) == 0: + level_db = -200 + else: + level_db = level_db*alpha_smooth + np.log(np.abs(sample))*(1 - alpha_smooth) + output_db = level_db + gain_db + diff_db = ref_level_db - output_db + + if level_db <= low_level_db: + alpha_adjust = 0 + elif output_db >= high_level_db: + alpha_adjust = alpha_overflow + elif (abs(diff_db) > track_range_db): + alpha_adjust = alpha_acquire + else: + alpha_adjust = alpha_track + + gain_db += diff_db * alpha_adjust + output[sample_idx] = tensor[sample_idx] * np.exp(gain_db) + return output diff --git a/torchsig/transforms/system_impairment/si.py b/torchsig/transforms/system_impairment/si.py index 7dbf8fa..97e33c6 100644 --- a/torchsig/transforms/system_impairment/si.py +++ b/torchsig/transforms/system_impairment/si.py @@ -1,11 +1,11 @@ import numpy as np from copy import deepcopy from scipy import signal as sp -from typing import Optional, Any, Union, List, Callable +from typing import Optional, Any, Union, List from torchsig.utils.types import SignalData, SignalDescription from torchsig.transforms.transforms import SignalTransform -from torchsig.transforms.system_impairment import si_functional +from torchsig.transforms.system_impairment import functional from torchsig.transforms.functional import NumericParameter, IntParameter, FloatParameter from torchsig.transforms.functional import to_distribution, uniform_continuous_distribution, uniform_discrete_distribution @@ -67,13 +67,13 @@ def __call__(self, data: Any) -> Any: ) # Apply data transformation - new_data.iq_data = si_functional.fractional_shift( + new_data.iq_data = functional.fractional_shift( data.iq_data, self.taps, self.interp_rate, -decimal_part # this needed to be negated to be consistent with the previous implementation ) - new_data.iq_data = si_functional.time_shift(new_data.iq_data, int(integer_part)) + new_data.iq_data = functional.time_shift(new_data.iq_data, int(integer_part)) # Update SignalDescription new_signal_description = [] @@ -91,13 +91,13 @@ def __call__(self, data: Any) -> Any: new_data.signal_description = new_signal_description else: - new_data = si_functional.fractional_shift( + new_data = functional.fractional_shift( data, self.taps, self.interp_rate, -decimal_part # this needed to be negated to be consistent with the previous implementation ) - new_data = si_functional.time_shift(new_data, int(integer_part)) + new_data = functional.time_shift(new_data, int(integer_part)) return new_data @@ -167,7 +167,7 @@ def __call__(self, data: Any) -> Any: ) # Perform data augmentation - new_data.iq_data = si_functional.time_crop(iq_data, start, self.length) + new_data.iq_data = functional.time_crop(iq_data, start, self.length) # Update SignalDescription new_signal_description = [] @@ -190,7 +190,7 @@ def __call__(self, data: Any) -> Any: new_data.signal_description = new_signal_description else: - new_data = si_functional.time_crop(data, start, self.length) + new_data = functional.time_crop(data, start, self.length) return new_data @@ -228,10 +228,10 @@ def __call__(self, data: Any) -> Any: ) # Perform data augmentation - new_data.iq_data = si_functional.time_reversal(data.iq_data) + new_data.iq_data = functional.time_reversal(data.iq_data) if undo_spec_inversion: # If spectral inversion not desired, reverse effect - new_data.iq_data = si_functional.spectral_inversion(new_data.iq_data) + new_data.iq_data = functional.spectral_inversion(new_data.iq_data) # Update SignalDescription new_signal_description = [] @@ -258,10 +258,10 @@ def __call__(self, data: Any) -> Any: new_data.signal_description = new_signal_description else: - new_data = si_functional.time_reversal(data) + new_data = functional.time_reversal(data) if undo_spec_inversion: # If spectral inversion not desired, reverse effect - new_data = si_functional.spectral_inversion(new_data) + new_data = functional.spectral_inversion(new_data) return new_data @@ -284,10 +284,10 @@ def __call__(self, data: Any) -> Any: ) # Perform data augmentation - new_data.iq_data = si_functional.amplitude_reversal(data.iq_data) + new_data.iq_data = functional.amplitude_reversal(data.iq_data) else: - new_data = si_functional.amplitude_reversal(data) + new_data = functional.amplitude_reversal(data) return new_data @@ -373,16 +373,134 @@ def __call__(self, data: Any) -> Any: # Apply data augmentation if avoid_aliasing: # If any potential aliasing detected, perform shifting at higher sample rate - new_data.iq_data = si_functional.freq_shift_avoid_aliasing(data.iq_data, freq_shift) + new_data.iq_data = functional.freq_shift_avoid_aliasing(data.iq_data, freq_shift) else: # Otherwise, use faster freq shifter - new_data.iq_data = si_functional.freq_shift(data.iq_data, freq_shift) + new_data.iq_data = functional.freq_shift(data.iq_data, freq_shift) else: - new_data = si_functional.freq_shift(data, freq_shift) + new_data = functional.freq_shift(data, freq_shift) return new_data +class RandomDelayedFrequencyShift(SignalTransform): + """Apply a delayed frequency shift to the input data + + Args: + start_shift (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + start_shift sets the start time of the delayed shift + * If Callable, produces a sample by calling start_shift() + * If int, start_shift is fixed at the value provided + * If list, start_shift is any element in the list + * If tuple, start_shift is in range of (tuple[0], tuple[1]) + + freq_shift (:py:class:`~Callable`, :obj:`int`, :obj:`float`, :obj:`list`, :obj:`tuple`): + freq_shift sets the translation along the freq-axis + * If Callable, produces a sample by calling freq_shift() + * If int, freq_shift is fixed at the value provided + * If list, freq_shift is any element in the list + * If tuple, freq_shift is in range of (tuple[0], tuple[1]) + + """ + def __init__( + self, + start_shift: IntParameter = uniform_continuous_distribution(0.1,0.9), + freq_shift: IntParameter = uniform_continuous_distribution(-0.2,0.2), + ): + super(RandomDelayedFrequencyShift, self).__init__() + self.start_shift = to_distribution(start_shift, self.random_generator) + self.freq_shift = to_distribution(freq_shift, self.random_generator) + + def __call__(self, data: Any) -> Any: + start_shift = self.start_shift() + # Randomly generate a freq shift that is not near the original fc + freq_shift = 0 + while freq_shift < 0.05 and freq_shift > -0.05: + freq_shift = self.freq_shift() + + if isinstance(data, SignalData): + # Create new SignalData object for transformed data + new_data = SignalData( + data=None, + item_type=np.dtype(np.float64), + data_type=np.dtype(np.complex128), + signal_description=[], + ) + new_data.iq_data = data.iq_data + num_iq_samples = data.iq_data.shape[0] + + # Setup new SignalDescription object + new_signal_description = [] + signal_description = [data.signal_description] if isinstance(data.signal_description, SignalDescription) else data.signal_description + avoid_aliasing = False + for signal_desc in signal_description: + new_signal_desc_first_seg = deepcopy(signal_desc) + new_signal_desc_sec_seg = deepcopy(signal_desc) + # Check bounds for partial signals + new_signal_desc_first_seg.lower_frequency = -0.5 if new_signal_desc_first_seg.lower_frequency < -0.5 else new_signal_desc_first_seg.lower_frequency + new_signal_desc_first_seg.upper_frequency = 0.5 if new_signal_desc_first_seg.upper_frequency > 0.5 else new_signal_desc_first_seg.upper_frequency + new_signal_desc_first_seg.bandwidth = new_signal_desc_first_seg.upper_frequency - new_signal_desc_first_seg.lower_frequency + new_signal_desc_first_seg.center_frequency = new_signal_desc_first_seg.lower_frequency + new_signal_desc_first_seg.bandwidth * 0.5 + + # Update time for original segment if present in segment and add to list + if new_signal_desc_first_seg.start < start_shift: + new_signal_desc_first_seg.stop = start_shift if new_signal_desc_first_seg.stop > start_shift else new_signal_desc_first_seg.stop + new_signal_desc_first_seg.duration = new_signal_desc_first_seg.stop - new_signal_desc_first_seg.start + # Append SignalDescription to list + new_signal_description.append(new_signal_desc_first_seg) + + # Begin second segment processing + new_signal_desc_sec_seg.lower_frequency = -0.5 if new_signal_desc_sec_seg.lower_frequency < -0.5 else new_signal_desc_sec_seg.lower_frequency + new_signal_desc_sec_seg.upper_frequency = 0.5 if new_signal_desc_sec_seg.upper_frequency > 0.5 else new_signal_desc_sec_seg.upper_frequency + new_signal_desc_sec_seg.bandwidth = new_signal_desc_sec_seg.upper_frequency - new_signal_desc_sec_seg.lower_frequency + new_signal_desc_sec_seg.center_frequency = new_signal_desc_sec_seg.lower_frequency + new_signal_desc_sec_seg.bandwidth * 0.5 + + # Update freqs for next segment + new_signal_desc_sec_seg.lower_frequency += freq_shift + new_signal_desc_sec_seg.upper_frequency += freq_shift + new_signal_desc_sec_seg.center_frequency += freq_shift + + # Check bounds for aliasing + if new_signal_desc_sec_seg.lower_frequency >= 0.5 or new_signal_desc_sec_seg.upper_frequency <= -0.5: + avoid_aliasing = True + continue + if new_signal_desc_sec_seg.lower_frequency < -0.45 or new_signal_desc_sec_seg.upper_frequency > 0.45: + avoid_aliasing = True + new_signal_desc_sec_seg.lower_frequency = -0.5 if new_signal_desc_sec_seg.lower_frequency < -0.5 else new_signal_desc_sec_seg.lower_frequency + new_signal_desc_sec_seg.upper_frequency = 0.5 if new_signal_desc_sec_seg.upper_frequency > 0.5 else new_signal_desc_sec_seg.upper_frequency + + # Update bw & fc + new_signal_desc_sec_seg.bandwidth = new_signal_desc_sec_seg.upper_frequency - new_signal_desc_sec_seg.lower_frequency + new_signal_desc_sec_seg.center_frequency = new_signal_desc_sec_seg.lower_frequency + new_signal_desc_sec_seg.bandwidth * 0.5 + + # Update time for shifted segment if present in segment and add to list + if new_signal_desc_sec_seg.stop > start_shift: + new_signal_desc_sec_seg.start = start_shift if new_signal_desc_sec_seg.start < start_shift else new_signal_desc_sec_seg.start + new_signal_desc_sec_seg.stop = new_signal_desc_sec_seg.stop + new_signal_desc_sec_seg.duration = new_signal_desc_sec_seg.stop - new_signal_desc_sec_seg.start + # Append SignalDescription to list + new_signal_description.append(new_signal_desc_sec_seg) + + # Update with the new SignalDescription + new_data.signal_description = new_signal_description + + # Perform augmentation + if avoid_aliasing: + # If any potential aliasing detected, perform shifting at higher sample rate + new_data.iq_data[int(start_shift*num_iq_samples):] = functional.freq_shift_avoid_aliasing( + data.iq_data[int(start_shift*num_iq_samples):], + freq_shift + ) + else: + # Otherwise, use faster freq shifter + new_data.iq_data[int(start_shift*num_iq_samples):] = functional.freq_shift( + data.iq_data[int(start_shift*num_iq_samples):], + freq_shift + ) + + return new_data + + class LocalOscillatorDrift(SignalTransform): """LocalOscillatorDrift is a transform modelling a local oscillator's drift in frequency by a random walk in frequency. @@ -600,7 +718,7 @@ def __call__(self, data: Any) -> Any: ref_level_db = np.random.uniform(-.5 + self.ref_level_db, .5 + self.ref_level_db, 1) - iq_data = si_functional.agc( + iq_data = functional.agc( np.ascontiguousarray(iq_data, dtype=np.complex64), np.float64(self.initial_gain_db), np.float64(alpha_smooth), @@ -677,14 +795,14 @@ def __call__(self, data: Any) -> Any: dc_offset = self.dc_offset() if isinstance(data, SignalData): - data.iq_data = si_functional.iq_imbalance( + data.iq_data = functional.iq_imbalance( data.iq_data, amp_imbalance, phase_imbalance, dc_offset ) else: - data = si_functional.iq_imbalance( + data = functional.iq_imbalance( data, amp_imbalance, phase_imbalance, @@ -742,9 +860,9 @@ def __call__(self, data: Any) -> Any: upper_freq = self.upper_freq() if np.random.rand() < self.upper_cut_apply else 1.0 order = self.order() if isinstance(data, SignalData): - data.iq_data = si_functional.roll_off(data.iq_data, low_freq, upper_freq, int(order)) + data.iq_data = functional.roll_off(data.iq_data, low_freq, upper_freq, int(order)) else: - data = si_functional.roll_off(data, low_freq, upper_freq, int(order)) + data = functional.roll_off(data, low_freq, upper_freq, int(order)) return data @@ -767,10 +885,10 @@ def __call__(self, data: Any) -> Any: ) # Apply data augmentation - new_data.iq_data = si_functional.add_slope(data.iq_data) + new_data.iq_data = functional.add_slope(data.iq_data) else: - new_data = si_functional.add_slope(data) + new_data = functional.add_slope(data) return new_data @@ -792,7 +910,7 @@ def __call__(self, data: Any) -> Any: ) # Perform data augmentation - new_data.iq_data = si_functional.spectral_inversion(data.iq_data) + new_data.iq_data = functional.spectral_inversion(data.iq_data) # Update SignalDescription new_signal_description = [] @@ -812,7 +930,7 @@ def __call__(self, data: Any) -> Any: new_data.signal_description = new_signal_description else: - new_data = si_functional.spectral_inversion(data) + new_data = functional.spectral_inversion(data) return new_data @@ -851,10 +969,10 @@ def __call__(self, data: Any) -> Any: new_data.signal_description = new_signal_description # Perform data augmentation - new_data.iq_data = si_functional.channel_swap(data.iq_data) + new_data.iq_data = functional.channel_swap(data.iq_data) else: - new_data = si_functional.channel_swap(data) + new_data = functional.channel_swap(data) return new_data @@ -901,10 +1019,10 @@ def __call__(self, data: Any) -> Any: ) # Perform data augmentation - new_data.iq_data = si_functional.mag_rescale(data.iq_data, start, scale) + new_data.iq_data = functional.mag_rescale(data.iq_data, start, scale) else: - new_data = si_functional.mag_rescale(data, start, scale) + new_data = functional.mag_rescale(data, start, scale) return new_data @@ -945,7 +1063,7 @@ def __init__( self, drop_rate: NumericParameter = uniform_continuous_distribution(0.01,0.05), size: NumericParameter = uniform_discrete_distribution(np.arange(1,10)), - fill: Union[Callable, List, str] = uniform_discrete_distribution(["ffill", "bfill", "mean", "zero"]), + fill: Union[List, str] = uniform_discrete_distribution(["ffill", "bfill", "mean", "zero"]), ): super(RandomDropSamples, self).__init__() self.drop_rate = to_distribution(drop_rate, self.random_generator) @@ -970,14 +1088,14 @@ def __call__(self, data: Any) -> Any: drop_sizes = self.size(drop_instances).astype(int) drop_starts = np.random.uniform(1, data.iq_data.shape[0]-max(drop_sizes)-1, drop_instances).astype(int) - new_data.iq_data = si_functional.drop_samples(data.iq_data, drop_starts, drop_sizes, fill) + new_data.iq_data = functional.drop_samples(data.iq_data, drop_starts, drop_sizes, fill) else: drop_instances = int(data.shape[0] * drop_rate) drop_sizes = self.size(drop_instances).astype(int) drop_starts = np.random.uniform(0, data.shape[0]-max(drop_sizes), drop_instances).astype(int) - new_data = si_functional.drop_samples(data, drop_starts, drop_sizes, fill) + new_data = functional.drop_samples(data, drop_starts, drop_sizes, fill) return new_data @@ -1022,10 +1140,10 @@ def __call__(self, data: Any) -> Any: ) # Perform data augmentation - new_data.iq_data = si_functional.quantize(data.iq_data, num_levels, round_type) + new_data.iq_data = functional.quantize(data.iq_data, num_levels, round_type) else: - new_data = si_functional.quantize(data, num_levels, round_type) + new_data = functional.quantize(data, num_levels, round_type) return new_data @@ -1063,10 +1181,10 @@ def __call__(self, data: Any) -> Any: ) # Apply data augmentation - new_data.iq_data = si_functional.clip(data.iq_data, clip_percentage) + new_data.iq_data = functional.clip(data.iq_data, clip_percentage) else: - new_data = si_functional.clip(data, clip_percentage) + new_data = functional.clip(data, clip_percentage) return new_data @@ -1117,8 +1235,8 @@ def __call__(self, data: Any) -> Any: ) # Apply data augmentation - new_data.iq_data = si_functional.random_convolve(data.iq_data, num_taps, alpha) + new_data.iq_data = functional.random_convolve(data.iq_data, num_taps, alpha) else: - new_data = si_functional.random_convolve(data, num_taps, alpha) + new_data = functional.random_convolve(data, num_taps, alpha) return new_data diff --git a/torchsig/transforms/target_transforms/target_transforms.py b/torchsig/transforms/target_transforms/target_transforms.py index b84b340..f41a046 100644 --- a/torchsig/transforms/target_transforms/target_transforms.py +++ b/torchsig/transforms/target_transforms/target_transforms.py @@ -1,3 +1,4 @@ +import torch import numpy as np from typing import Tuple, List, Any, Union, Optional @@ -117,6 +118,518 @@ def __call__( return classes[0], snrs[0] +class DescToMask(Transform): + """Transform to transform SignalDescriptions into spectrogram masks + + Args: + max_bursts (:obj:`int`): + Maximum number of bursts to label in their own target channel + width (:obj:`int`): + Width of resultant spectrogram mask + height (:obj:`int`): + Height of resultant spectrogram mask + + """ + def __init__(self, max_bursts: int, width: int, height: int): + super(DescToMask, self).__init__() + self.max_bursts = max_bursts + self.width = width + self.height = height + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + # Handle cases of both SignalDescriptions and lists of SignalDescriptions + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + masks = np.zeros((self.max_bursts, self.height, self.width)) + idx = 0 + for signal_desc in signal_description: + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + if int((signal_desc.lower_frequency+0.5) * self.height) == int((signal_desc.upper_frequency+0.5) * self.height): + masks[ + idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height)+1, + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + else: + masks[ + idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height), + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + idx += 1 + return masks + + +class DescToMaskSignal(Transform): + """Transform to transform SignalDescriptions into spectrogram masks for binary + signal detection + + Args: + width (:obj:`int`): + Width of resultant spectrogram mask + height (:obj:`int`): + Height of resultant spectrogram mask + + """ + def __init__(self, width: int, height: int): + super(DescToMaskSignal, self).__init__() + self.width = width + self.height = height + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + # Handle cases of both SignalDescriptions and lists of SignalDescriptions + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + masks = np.zeros((self.height, self.width)) + for signal_desc in signal_description: + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + if int((signal_desc.lower_frequency+0.5) * self.height) == int((signal_desc.upper_frequency+0.5) * self.height): + masks[ + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height)+1, + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + else: + masks[ + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height), + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + return masks + + +class DescToMaskFamily(Transform): + """Transform to transform SignalDescriptions into spectrogram masks with + different channels for each class's family. If no `class_family_dict` + provided, the default mapping for the WBSig53 modulation families is used. + + Args: + class_family_dict (:obj:`dict`): + Dictionary mapping all class names to their families + family_list (:obj:`list`): + List of all of the families + width (:obj:`int`): + Width of resultant spectrogram mask + height (:obj:`int`): + Height of resultant spectrogram mask + + """ + class_family_dict = { + '4ask':'ask', + '8ask':'ask', + '16ask':'ask', + '32ask':'ask', + '64ask':'ask', + 'ook':'pam', + '4pam':'pam', + '8pam':'pam', + '16pam':'pam', + '32pam':'pam', + '64pam':'pam', + '2fsk':'fsk', + '2gfsk':'fsk', + '2msk':'fsk', + '2gmsk':'fsk', + '4fsk':'fsk', + '4gfsk':'fsk', + '4msk':'fsk', + '4gmsk':'fsk', + '8fsk':'fsk', + '8gfsk':'fsk', + '8msk':'fsk', + '8gmsk':'fsk', + '16fsk':'fsk', + '16gfsk':'fsk', + '16msk':'fsk', + '16gmsk':'fsk', + 'bpsk':'psk', + 'qpsk':'psk', + '8psk':'psk', + '16psk':'psk', + '32psk':'psk', + '64psk':'psk', + '16qam':'qam', + '32qam':'qam', + '32qam_cross':'qam', + '64qam':'qam', + '128qam_cross':'qam', + '256qam':'qam', + '512qam_cross':'qam', + '1024qam':'qam', + 'ofdm-64':'ofdm', + 'ofdm-72':'ofdm', + 'ofdm-128':'ofdm', + 'ofdm-180':'ofdm', + 'ofdm-256':'ofdm', + 'ofdm-300':'ofdm', + 'ofdm-512':'ofdm', + 'ofdm-600':'ofdm', + 'ofdm-900':'ofdm', + 'ofdm-1024':'ofdm', + 'ofdm-1200':'ofdm', + 'ofdm-2048':'ofdm', + } + def __init__( + self, + width: int, + height: int, + class_family_dict: dict = None, + family_list: list = None, + label_encode: bool = False, + ): + super(DescToMaskFamily, self).__init__() + self.class_family_dict = class_family_dict if class_family_dict else self.class_family_dict + self.family_list = family_list if family_list else sorted(list(set(self.class_family_dict.values()))) + self.width = width + self.height = height + self.label_encode = label_encode + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + # Handle cases of both SignalDescriptions and lists of SignalDescriptions + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + masks = np.zeros((len(self.family_list), self.height, self.width)) + for signal_desc in signal_description: + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + if isinstance(signal_desc.class_name, list): + signal_desc.class_name = signal_desc.class_name[0] + family_name = self.class_family_dict[signal_desc.class_name] + family_idx = self.family_list.index(family_name) + if int((signal_desc.lower_frequency+0.5) * self.height) == int((signal_desc.upper_frequency+0.5) * self.height): + masks[ + family_idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height)+1, + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + else: + masks[ + family_idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height), + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + if self.label_encode: + background_mask = np.zeros((1, self.height, self.height)) + masks = np.concatenate([background_mask, masks], axis=0) + masks = np.argmax(masks, axis=0) + return masks + + +class DescToMaskClass(Transform): + """Transform to transform list of SignalDescriptions into spectrogram masks + with classes + + Args: + num_classes (:obj:`int`): + Integer number of classes, setting the channel dimension of the resultant mask + width (:obj:`int`): + Width of resultant spectrogram mask + height (:obj:`int`): + Height of resultant spectrogram mask + + """ + def __init__(self, num_classes: int, width: int, height: int): + super(DescToMaskClass, self).__init__() + self.num_classes = num_classes + self.width = width + self.height = height + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + # Handle cases of both SignalDescriptions and lists of SignalDescriptions + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + masks = np.zeros((self.num_classes, self.height, self.width)) + for signal_desc in signal_description: + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + if int((signal_desc.lower_frequency+0.5) * self.height) == int((signal_desc.upper_frequency+0.5) * self.height): + masks[ + signal_desc.class_index, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height)+1, + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + else: + masks[ + signal_desc.class_index, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height), + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + return masks + + +class DescToSemanticClass(Transform): + """Transform to transform SignalDescriptions into spectrogram semantic + segmentation mask with class information denoted as a value, rather than by + a one/multi-hot vector in an additional channel like the + DescToMaskClass does. Note that the class indicies are all + incremented by 1 in order to reserve the 0 class for "background". Note + that cases of overlapping bursts are currently resolved by comparing SNRs, + labeling the pixel by the stronger signal. Ties in SNR are awarded to the + burst that appears later in the burst collection. + + Args: + num_classes (:obj:`int`): + Integer number of classes, setting the channel dimension of the resultant mask + width (:obj:`int`): + Width of resultant spectrogram mask + height (:obj:`int`): + Height of resultant spectrogram mask + + """ + def __init__(self, num_classes: int, width: int, height: int): + super(DescToSemanticClass, self).__init__() + self.num_classes = num_classes + self.width = width + self.height = height + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + # Handle cases of both SignalDescriptions and lists of SignalDescriptions + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + masks = np.zeros((self.height, self.width)) + curr_snrs = np.ones((self.height, self.width))*-np.inf + for signal_desc in signal_description: + # Normalize freq values to [0,1] + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + + # Convert to pixels + height_start = max(0, int((signal_desc.lower_frequency+0.5) * self.height)) + height_stop = min(int((signal_desc.upper_frequency+0.5) * self.height), self.height) + width_start = max(0, int(signal_desc.start * self.width)) + width_stop = min(int(signal_desc.stop * self.width), self.width) + + # Account for signals with bandwidths < a pixel + if height_start == height_stop: + height_stop = min(height_stop+1, self.height) + + # Loop through pixels + for height_idx in range(height_start, height_stop): + for width_idx in range(width_start, width_stop): + # Check SNR against currently stored SNR at pixel + if signal_desc.snr >= curr_snrs[height_idx, width_idx]: + # If SNR >= currently stored class's SNR, update class & snr + masks[ + height_start : height_stop, + width_start : width_stop, + ] = signal_desc.class_index+1 + curr_snrs[ + height_start : height_stop, + width_start : width_stop, + ] = signal_desc.snr_db + return masks + + +class DescToBBox(Transform): + """Transform to transform SignalDescriptions into spectrogram bounding boxes + with dimensions: , where the last 5 represents: + - 0: presence ~ 1 if center of burst in current cell, else 0 + - 1: center_time ~ normalized to cell + - 2: dur_time ~ normalized to full spec time + - 3: center_freq ~ normalized to cell + - 4: bw_freq ~ normalized to full spec bw + + Args: + grid_width (:obj:`int`): + Width of grid celling + grid_height (:obj:`int`): + Height of grid celling + + """ + def __init__(self, grid_width: int, grid_height: int): + super(DescToBBox, self).__init__() + self.grid_width = grid_width + self.grid_height = grid_height + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + # Handle cases of both SignalDescriptions and lists of SignalDescriptions + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + boxes = np.zeros((self.grid_width, self.grid_height, 5)) + for signal_desc in signal_description: + # Time conversions + if signal_desc.start >= 1.0: + # Burst starts outside of window of capture + continue + elif signal_desc.start + signal_desc.duration * 0.5 >= 1.0: + # Center is outside grid cell; re-center to truncated burst + signal_desc.duration = 1 - signal_desc.start + x = (signal_desc.start + signal_desc.duration * 0.5) * self.grid_width + time_cell = int(np.floor(x)) + center_time = x - time_cell + + # Freq conversions + if signal_desc.lower_frequency > 0.5 or signal_desc.upper_frequency < -0.5: + # Burst is fully outside of capture bandwidth + continue + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + signal_desc.bandwidth = signal_desc.upper_frequency - signal_desc.lower_frequency + signal_desc.center_frequency = signal_desc.lower_frequency + signal_desc.bandwidth / 2 + y = (signal_desc.center_frequency + 0.5) * self.grid_height + freq_cell = int(np.floor(y)) + center_freq = y - freq_cell + + if time_cell >= self.grid_width: + print("Error: time_cell idx is greater than grid_width") + print("time_cell: {}".format(time_cell)) + print("burst.start: {}".format(signal_desc.start)) + print("burst.duration: {}".format(signal_desc.duration)) + print("x: {}".format(x)) + if freq_cell >= self.grid_height: + print("Error: freq_cell idx is greater than grid_height") + print("freq_cell: {}".format(freq_cell)) + print("burst.lower_frequency: {}".format(signal_desc.lower_frequency)) + print("burst.upper_frequency: {}".format(signal_desc.upper_frequency)) + print("burst.center_frequency: {}".format(signal_desc.center_frequency)) + print("y: {}".format(y)) + + # Assign to label + boxes[time_cell, freq_cell, 0] = 1 + boxes[time_cell, freq_cell, 1] = center_time + boxes[time_cell, freq_cell, 2] = signal_desc.duration + boxes[time_cell, freq_cell, 3] = center_freq + boxes[time_cell, freq_cell, 4] = signal_desc.bandwidth + return boxes + + +class DescToAnchorBoxes(Transform): + """Transform to transform BurstCollections into spectrogram bounding boxes + using anchor boxes, such that the output target shape will have the + dimensions: , where the last 5 represents: + - 0: objectness ~ 1 if burst associated with current cell & anchor, else 0 + - 1: center_time ~ normalized to cell + - 2: dur_offset ~ offset in duration with anchor box duration + - 3: center_freq ~ normalized to cell + - 4: bw_offset ~ offset in bandwidth with anchor box duration + + Args: + grid_width (:obj:`int`): + Width of grid celling + grid_height (:obj:`int`): + Height of grid celling + anchor_boxes: + List of tuples describing the anchor boxes (normalized values) + Example format: [(dur1, bw1), (dur2, bw2)] + + """ + def __init__(self, grid_width: int, grid_height: int, anchor_boxes: List): + super(DescToAnchorBoxes, self).__init__() + self.grid_width = grid_width + self.grid_height = grid_height + self.anchor_boxes = anchor_boxes + self.num_anchor_boxes = len(anchor_boxes) + + # IoU function + def iou(self, start_a, dur_a, center_freq_a, bw_a, start_b, dur_b, center_freq_b, bw_b): + # Convert to start/stops + x_start_a = start_a + x_stop_a = start_a + dur_a + y_start_a = center_freq_a - bw_a/2 + y_stop_a = center_freq_a + bw_a/2 + + x_start_b = start_b + x_stop_b = start_b + dur_b + y_start_b = center_freq_b - bw_b/2 + y_stop_b = center_freq_b + bw_b/2 + + # Determine the (x, y)-coordinates of the intersection + x_start_int = max(x_start_a, x_start_b) + y_start_int = max(y_start_a, y_start_b) + x_stop_int = min(x_stop_a, x_stop_b) + y_stop_int = min(y_stop_a, y_stop_b) + + # Compute the area of intersection + inter_area = abs(max((x_stop_int - x_start_int, 0)) * max((y_stop_int - y_start_int), 0)) + if inter_area == 0: + return 0 + # Compute the area of both the prediction and ground-truth + area_a = abs((x_stop_a - x_start_a) * (y_stop_a - y_start_a)) + area_b = abs((x_stop_b - x_start_b) * (y_stop_b - y_start_b)) + + # Compute the intersection over union + iou = inter_area / float(area_a + area_b - inter_area) + return iou + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + # Handle cases of both SignalDescriptions and lists of SignalDescriptions + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + boxes = np.zeros((self.grid_width, self.grid_height, 5*self.num_anchor_boxes)) + for signal_desc in signal_description: + # Time conversions + if signal_desc.start > 1.0: + # Error handling (TODO: should fix within dataset) + continue + elif signal_desc.start + signal_desc.duration * 0.5 > 1.0: + # Center is outside grid cell; re-center to truncated burst + signal_desc.duration = 1 - signal_desc.start + x = (signal_desc.start + signal_desc.duration * 0.5) * self.grid_width + time_cell = int(np.floor(x)) + center_time = x - time_cell + + # Freq conversions + y = (signal_desc.center_frequency + 0.5) * self.grid_height + freq_cell = int(np.floor(y)) + center_freq = y - freq_cell + + # Debugging messages for potential errors + if time_cell > self.grid_width: + print("Error: time_cell idx is greater than grid_width") + print("time_cell: {}".format(time_cell)) + print("burst.start: {}".format(signal_desc.start)) + print("burst.duration: {}".format(signal_desc.duration)) + print("x: {}".format(x)) + if freq_cell > self.grid_height: + print("Error: freq_cell idx is greater than grid_height") + print("freq_cell: {}".format(freq_cell)) + print("burst.center_frequency: {}".format(signal_desc.center_frequency)) + print("y: {}".format(y)) + + # Determine which anchor box to associate burst with + best_iou_score = -1 + best_iou_idx = 0 + best_anchor_duration = 0 + best_anchor_bw = 0 + for anchor_idx, anchor_box in enumerate(self.anchor_boxes): + #anchor_start = ((time_cell+0.5) / self.grid_width) - (anchor_box[0]*0.5) # Anchor centered on cell + anchor_start = signal_desc.start + 0.5*signal_desc.duration - anchor_box[0]*0.5 # Anchor overlaid on burst + anchor_duration = anchor_box[0] + #anchor_center_freq = (freq_cell+0.5) / self.grid_height # Anchor centered on cell + anchor_center_freq = signal_desc.center_frequency # Anchor overlaid on burst + anchor_bw = anchor_box[1] + iou_score = self.iou(signal_desc.start, signal_desc.duration, signal_desc.center_frequency, signal_desc.bandwidth, + anchor_start, anchor_duration, anchor_center_freq, anchor_bw) + if iou_score > best_iou_score and boxes[time_cell, freq_cell, 0+5*anchor_idx] != 1: + # If IoU score is the best out of all anchors and anchor hasn't already been used for another burst, save results + best_iou_score = iou_score + best_iou_idx = anchor_idx + best_anchor_duration = anchor_duration + best_anchor_bw = anchor_bw + + # Convert absolute coordinates to anchor-box offsets + # centers are normalized values like previous code segment below + # width/height are relative values to anchor boxes + # -- if anchor width is 0.6; true width is 0.5; label width should be 0.5/0.6 + # -- if anchor height is 0.6; true height is 0.7; label height should be 0.7/0.6 + # -- loss & inference will require predicted_box_wh = (sigmoid(model_output_wh)*2)**2 * anchor_wh + if best_iou_score > 0: + # Detection: + boxes[time_cell, freq_cell, 0+5*best_iou_idx] = 1 + # Center time & freq + boxes[time_cell, freq_cell, 1+5*best_iou_idx] = center_time + boxes[time_cell, freq_cell, 3+5*best_iou_idx] = center_freq + # Duration/Bandwidth (Width/Height) + boxes[time_cell, freq_cell, 2+5*best_iou_idx] = signal_desc.duration / best_anchor_duration + boxes[time_cell, freq_cell, 4+5*best_iou_idx] = signal_desc.bandwidth / best_anchor_bw + return boxes + + class DescPassThrough(Transform): """Transform to simply pass the SignalDescription through. Same as applying no transform in most cases. @@ -256,6 +769,465 @@ def __call__(self, signal_description: Union[List[SignalDescription], SignalDesc return encoding +class DescToBBoxDict(Transform): + """Transform to transform SignalDescriptions into the class bounding box format + using dictionaries of labels and boxes, similar to the COCO image dataset + + Args: + class_list (:obj:`list`): + List of class names. Used when converting SignalDescription class names + to indices + + """ + def __init__(self, class_list): + super(DescToBBoxDict, self).__init__() + self.class_list = class_list + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + labels = [] + boxes = np.empty((len(signal_description),4)) + for signal_desc_idx, signal_desc in enumerate(signal_description): + #xcycwh + duration = signal_desc.stop - signal_desc.start + bandwidth = signal_desc.upper_frequency - signal_desc.lower_frequency + boxes[signal_desc_idx] = np.array([ + signal_desc.start + 0.5*duration, + signal_desc.lower_frequency + 0.5 + 0.5*bandwidth, + duration, + bandwidth + ]) + labels.append(self.class_list.index(signal_desc.class_name)) + + targets = {"labels":torch.Tensor(labels).long(), "boxes":torch.Tensor(boxes)} + return targets + + +class DescToBBoxSignalDict(Transform): + """Transform to transform SignalDescriptions into the class bounding box format + using dictionaries of labels and boxes, similar to the COCO image dataset. + Differs from the `SignalDescriptionToBoundingBoxDictTransform` in the ommission + of signal-specific class labels, grouping all objects into the 'signal' + class. + + """ + def __init__(self): + super(DescToBBoxSignalDict, self).__init__() + self.class_list = ["signal"] + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + labels = [] + boxes = np.empty((len(signal_description),4)) + for signal_desc_idx, signal_desc in enumerate(signal_description): + #xcycwh + duration = signal_desc.stop - signal_desc.start + bandwidth = signal_desc.upper_frequency - signal_desc.lower_frequency + boxes[signal_desc_idx] = np.array([ + signal_desc.start + 0.5*duration, + signal_desc.lower_frequency + 0.5 + 0.5*bandwidth, + duration, + bandwidth + ]) + labels.append(self.class_list.index(self.class_list[0])) + + targets = {"labels":torch.Tensor(labels).long(), "boxes":torch.Tensor(boxes)} + return targets + + +class DescToBBoxFamilyDict(Transform): + """Transform to transform SignalDescriptions into the class bounding box format + using dictionaries of labels and boxes, similar to the COCO image dataset. + Differs from the `DescToBBoxDict` transform in the grouping + of fine-grain classes into their signal family as defined by an input + `class_family_dict` dictionary. + + Args: + class_family_dict (:obj:`dict`): + Dictionary mapping all class names to their families + + """ + class_family_dict = { + '4ask':'ask', + '8ask':'ask', + '16ask':'ask', + '32ask':'ask', + '64ask':'ask', + 'ook':'pam', + '4pam':'pam', + '8pam':'pam', + '16pam':'pam', + '32pam':'pam', + '64pam':'pam', + '2fsk':'fsk', + '2gfsk':'fsk', + '2msk':'fsk', + '2gmsk':'fsk', + '4fsk':'fsk', + '4gfsk':'fsk', + '4msk':'fsk', + '4gmsk':'fsk', + '8fsk':'fsk', + '8gfsk':'fsk', + '8msk':'fsk', + '8gmsk':'fsk', + '16fsk':'fsk', + '16gfsk':'fsk', + '16msk':'fsk', + '16gmsk':'fsk', + 'bpsk':'psk', + 'qpsk':'psk', + '8psk':'psk', + '16psk':'psk', + '32psk':'psk', + '64psk':'psk', + '16qam':'qam', + '32qam':'qam', + '32qam_cross':'qam', + '64qam':'qam', + '128qam_cross':'qam', + '256qam':'qam', + '512qam_cross':'qam', + '1024qam':'qam', + 'ofdm-64':'ofdm', + 'ofdm-72':'ofdm', + 'ofdm-128':'ofdm', + 'ofdm-180':'ofdm', + 'ofdm-256':'ofdm', + 'ofdm-300':'ofdm', + 'ofdm-512':'ofdm', + 'ofdm-600':'ofdm', + 'ofdm-900':'ofdm', + 'ofdm-1024':'ofdm', + 'ofdm-1200':'ofdm', + 'ofdm-2048':'ofdm', + } + def __init__(self, class_family_dict: dict = None, family_list: list = None): + super(DescToBBoxFamilyDict, self).__init__() + self.class_family_dict = class_family_dict if class_family_dict else self.class_family_dict + self.family_list = family_list if family_list else sorted(list(set(self.class_family_dict.values()))) + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + labels = [] + boxes = np.empty((len(signal_description),4)) + for signal_desc_idx, signal_desc in enumerate(signal_description): + #xcycwh + duration = signal_desc.stop - signal_desc.start + bandwidth = signal_desc.upper_frequency - signal_desc.lower_frequency + boxes[signal_desc_idx] = np.array([ + signal_desc.start + 0.5*duration, + signal_desc.lower_frequency + 0.5 + 0.5*bandwidth, + duration, + bandwidth + ]) + if isinstance(signal_desc.class_name, list): + signal_desc.class_name = signal_desc.class_name[0] + family_name = self.class_family_dict[signal_desc.class_name] + labels.append(self.family_list.index(family_name)) + + targets = {"labels":torch.Tensor(labels).long(), "boxes":torch.Tensor(boxes)} + return targets + + +class DescToInstMaskDict(Transform): + """Transform to transform SignalDescriptions into the class mask format + using dictionaries of labels and masks, similar to the COCO image dataset + + Args: + class_list (:obj:`list`): + List of class names. Used when converting SignalDescription class names + to indices + width (:obj:`int`): + Width of masks + heigh (:obj:`int`): + Height of masks + + """ + def __init__( + self, + class_list: List = [], + width: int = 512, + height: int = 512, + ): + super(DescToInstMaskDict, self).__init__() + self.class_list = class_list + self.width = width + self.height = height + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + num_objects = len(signal_description) + labels = [] + masks = np.zeros((num_objects, self.height, self.width)) + for signal_desc_idx, signal_desc in enumerate(signal_description): + labels.append(self.class_list.index(signal_desc.class_name)) + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + if int((signal_desc.lower_frequency+0.5) * self.height) == int((signal_desc.upper_frequency+0.5) * self.height): + masks[ + signal_desc_idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height)+1, + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + else: + masks[ + signal_desc_idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height), + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + + targets = {"labels":torch.Tensor(labels).long(), "masks":torch.Tensor(masks.astype(bool))} + return targets + + +class DescToSignalInstMaskDict(Transform): + """Transform to transform SignalDescriptions into the class mask format + using dictionaries of labels and masks, similar to the COCO image dataset + + Args: + width (:obj:`int`): + Width of masks + heigh (:obj:`int`): + Height of masks + + """ + def __init__( + self, + width: int = 512, + height: int = 512, + ): + super(DescToSignalInstMaskDict, self).__init__() + self.width = width + self.height = height + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + num_objects = len(signal_description) + labels = [] + masks = np.zeros((num_objects, self.height, self.width)) + for signal_desc_idx, signal_desc in enumerate(signal_description): + labels.append(0) + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + if int((signal_desc.lower_frequency+0.5) * self.height) == int((signal_desc.upper_frequency+0.5) * self.height): + masks[ + signal_desc_idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height)+1, + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + else: + masks[ + signal_desc_idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height), + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + + targets = {"labels":torch.Tensor(labels).long(), "masks":torch.Tensor(masks.astype(bool))} + return targets + + +class DescToSignalFamilyInstMaskDict(Transform): + """Transform to transform SignalDescriptions into the class mask format + using dictionaries of labels and masks, similar to the COCO image dataset. + The labels with this target transform are set to be the class's family. If + no `class_family_dict` is provided, the default mapping for the WBSig53 + modulation families is used. + + Args: + class_family_dict (:obj:`dict`): + Dictionary mapping all class names to their families + family_list (:obj:`list`): + List of all of the families + width (:obj:`int`): + Width of resultant spectrogram mask + height (:obj:`int`): + Height of resultant spectrogram mask + + """ + class_family_dict = { + '4ask':'ask', + '8ask':'ask', + '16ask':'ask', + '32ask':'ask', + '64ask':'ask', + 'ook':'pam', + '4pam':'pam', + '8pam':'pam', + '16pam':'pam', + '32pam':'pam', + '64pam':'pam', + '2fsk':'fsk', + '2gfsk':'fsk', + '2msk':'fsk', + '2gmsk':'fsk', + '4fsk':'fsk', + '4gfsk':'fsk', + '4msk':'fsk', + '4gmsk':'fsk', + '8fsk':'fsk', + '8gfsk':'fsk', + '8msk':'fsk', + '8gmsk':'fsk', + '16fsk':'fsk', + '16gfsk':'fsk', + '16msk':'fsk', + '16gmsk':'fsk', + 'bpsk':'psk', + 'qpsk':'psk', + '8psk':'psk', + '16psk':'psk', + '32psk':'psk', + '64psk':'psk', + '16qam':'qam', + '32qam':'qam', + '32qam_cross':'qam', + '64qam':'qam', + '128qam_cross':'qam', + '256qam':'qam', + '512qam_cross':'qam', + '1024qam':'qam', + 'ofdm-64':'ofdm', + 'ofdm-72':'ofdm', + 'ofdm-128':'ofdm', + 'ofdm-180':'ofdm', + 'ofdm-256':'ofdm', + 'ofdm-300':'ofdm', + 'ofdm-512':'ofdm', + 'ofdm-600':'ofdm', + 'ofdm-900':'ofdm', + 'ofdm-1024':'ofdm', + 'ofdm-1200':'ofdm', + 'ofdm-2048':'ofdm', + } + def __init__( + self, + width: int, + height: int, + class_family_dict: dict = None, + family_list: list = None, + ): + super(DescToSignalFamilyInstMaskDict, self).__init__() + self.class_family_dict = class_family_dict if class_family_dict else self.class_family_dict + self.family_list = family_list if family_list else sorted(list(set(self.class_family_dict.values()))) + self.width = width + self.height = height + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> np.ndarray: + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + num_objects = len(signal_description) + labels = [] + masks = np.zeros((num_objects, self.height, self.width)) + for signal_desc_idx, signal_desc in enumerate(signal_description): + family_name = self.class_family_dict[signal_desc.class_name] + family_idx = self.family_list.index(family_name) + labels.append(family_idx) + if signal_desc.lower_frequency < -0.5: + signal_desc.lower_frequency = -0.5 + if signal_desc.upper_frequency > 0.5: + signal_desc.upper_frequency = 0.5 + if int((signal_desc.lower_frequency+0.5) * self.height) == int((signal_desc.upper_frequency+0.5) * self.height): + masks[ + signal_desc_idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height)+1, + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + else: + masks[ + signal_desc_idx, + int((signal_desc.lower_frequency+0.5) * self.height) : int((signal_desc.upper_frequency+0.5) * self.height), + int(signal_desc.start * self.width) : int(signal_desc.stop * self.width), + ] = 1.0 + + targets = {"labels":torch.Tensor(labels).long(), "masks":torch.Tensor(masks.astype(bool))} + return targets + + +class DescToListTuple(Transform): + """Transform to transform SignalDescription into a list of tuples containing + the modulation, start time, stop time, center frequency, bandwidth, and SNR + for each signal present + + Args: + precision (:obj: `np.dtype`): + Specify the data type precision for the tuple's information + + """ + def __init__(self, precision: np.dtype = np.dtype(np.float16)): + super(DescToListTuple, self).__init__() + self.precision = precision + + def __call__(self, signal_description: Union[List[SignalDescription], SignalDescription]) -> Union[List[str], str]: + output = [] + # Handle cases of both SignalDescriptions and lists of SignalDescriptions + signal_description = [signal_description] if isinstance(signal_description, SignalDescription) else signal_description + # Loop through SignalDescription's, converting values of interest to tuples + for signal_desc_idx, signal_desc in enumerate(signal_description): + curr_tuple = ( + signal_desc.class_name[0], + self.precision.type(signal_desc.start), + self.precision.type(signal_desc.stop), + self.precision.type(signal_desc.center_frequency), + self.precision.type(signal_desc.bandwidth), + self.precision.type(signal_desc.snr), + ) + output.append(curr_tuple) + return output + + +class ListTupleToDesc(Transform): + """Transform to transform a list of tuples to a list of SignalDescriptions + Sample rate and number of IQ samples optional arguments are provided in + order to fill in additional information if desired. If a class list is + provided, the class names are used with the list to fill in class indices + + Args: + sample_rate (:obj: `Optional[float]`): + Optionally provide the sample rate for the SignalDescriptions + + num_iq_samples (:obj: `Optional[int]`): + Optionally provide the number of IQ samples for the SignalDescriptions + + class_list (:obj: `List`): + Optionally provide the class list to fill in class indices + + """ + def __init__( + self, + sample_rate: Optional[float] = 1.0, + num_iq_samples: Optional[int] = int(512*512), + class_list: Optional[List] = None, + ): + super(ListTupleToDesc, self).__init__() + self.sample_rate = sample_rate + self.num_iq_samples = num_iq_samples + self.class_list = class_list + + def __call__(self, list_tuple: List[Tuple]) -> List[SignalDescription]: + output = [] + # Loop through SignalDescription's, converting values of interest to tuples + for tuple_idx, curr_tuple in enumerate(list_tuple): + curr_signal_desc = SignalDescription( + sample_rate=self.sample_rate, + num_iq_samples=self.num_iq_samples, + class_name=curr_tuple[0], + class_index=self.class_list.index(curr_tuple[0]) if self.class_list else None, + start=curr_tuple[1], + stop=curr_tuple[2], + center_frequency=curr_tuple[3], + bandwidth=curr_tuple[4], + lower_frequency=curr_tuple[3]-curr_tuple[4]/2, + upper_frequency=curr_tuple[3]+curr_tuple[4]/2, + snr=curr_tuple[5], + ) + output.append(curr_signal_desc) + return output + + class LabelSmoothing(Transform): """Transform to transform a numpy array encoding to a smoothed version to assist with overconfidence. The input hyperparameter `alpha` determines the @@ -286,4 +1258,4 @@ def __init__(self, alpha: float = 0.1) -> np.ndarray: def __call__(self, encoding: np.ndarray) -> np.ndarray: return (1 - self.alpha) / np.sum(encoding) * encoding + (self.alpha / encoding.shape[0]) - + \ No newline at end of file diff --git a/torchsig/transforms/transforms.py b/torchsig/transforms/transforms.py index 2496527..0c8cc78 100644 --- a/torchsig/transforms/transforms.py +++ b/torchsig/transforms/transforms.py @@ -225,3 +225,33 @@ def __call__(self, data: Any) -> Any: for t in transforms: data = t(data) return data + + +class RandChoice(SignalTransform): + """RandChoice inputs a list of transforms and their associated + probabilities. When called, a single transform will be sampled from the + list using the probabilities provided, and then the selected transform + will operate on the input data. + + Args: + transforms (:obj:`list`): + List of transforms to sample from and then apply + probabilities (:obj:`list`): + Probabilities used when sampling the above list of transforms + + """ + def __init__( + self, + transforms: List[SignalTransform], + probabilities: Optional[List[float]] = None, + **kwargs, + ): + super(RandChoice, self).__init__(**kwargs) + self.transforms = transforms + self.probabilities = probabilities if probabilities else np.ones(len(self.transforms))/len(self.transforms) + if sum(self.probabilities) != 1.0: + self.probabilities /= sum(self.probabilities) + + def __call__(self, data: Any) -> Any: + t = self.random_generator.choice(self.transforms, p=self.probabilities) + return t(data) \ No newline at end of file diff --git a/torchsig/transforms/wireless_channel/__init__.py b/torchsig/transforms/wireless_channel/__init__.py index fcfb11f..4da9f8b 100644 --- a/torchsig/transforms/wireless_channel/__init__.py +++ b/torchsig/transforms/wireless_channel/__init__.py @@ -1,2 +1,2 @@ from .wce import * -from .wce_functional import * +from .functional import * diff --git a/torchsig/transforms/wireless_channel/functional.py b/torchsig/transforms/wireless_channel/functional.py new file mode 100644 index 0000000..b96a4e4 --- /dev/null +++ b/torchsig/transforms/wireless_channel/functional.py @@ -0,0 +1,163 @@ +import numpy as np +from numba import njit +from scipy import signal as sp +from scipy import interpolate + + +@njit(cache=False) +def make_sinc_filter(beta, tap_cnt, sps, offset=0): + """ + return the taps of a sinc filter + """ + ntap_cnt = tap_cnt + ((tap_cnt + 1) % 2) + t_index = np.arange(-(ntap_cnt - 1) // 2, (ntap_cnt - 1) // 2 + 1) / np.double(sps) + + taps = np.sinc(beta * t_index + offset) + taps /= np.sum(taps) + + return taps[:tap_cnt] + + +def awgn(tensor: np.ndarray, noise_power_db: float) -> np.ndarray: + """Adds zero-mean complex additive white Gaussian noise with power of + noise_power_db. + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + noise_power_db (:obj:`float`): + Defined as 10*log10(E[|n|^2]). + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor with added noise. + """ + real_noise = np.random.randn(*tensor.shape) + imag_noise = np.random.randn(*tensor.shape) + return tensor + (10.0**(noise_power_db/20.0))*(real_noise + 1j*imag_noise)/np.sqrt(2) + + +def time_varying_awgn( + tensor: np.ndarray, + noise_power_db_low: float, + noise_power_db_high: float, + inflections: int, + random_regions: bool, +) -> np.ndarray: + """Adds time-varying complex additive white Gaussian noise with power + levels in range (`noise_power_db_low`, `noise_power_db_high`) and with + `inflections` number of inflection points spread over the input tensor + randomly if `random_regions` is True or evely spread if False + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + noise_power_db_low (:obj:`float`): + Defined as 10*log10(E[|n|^2]). + + noise_power_db_high (:obj:`float`): + Defined as 10*log10(E[|n|^2]). + + inflections (:obj:`int`): + Number of inflection points for time-varying nature + + random_regions (:obj:`bool`): + Specify if inflection points are randomly spread throughout tensor + or if evenly spread + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor with added noise. + """ + real_noise = np.random.randn(*tensor.shape) + imag_noise = np.random.randn(*tensor.shape) + noise_power_db = np.empty(*tensor.shape) + + if inflections == 0: + inflection_indices = np.array([0, tensor.shape[0]]) + else: + if random_regions: + inflection_indices = np.sort(np.random.choice(tensor.shape[0], size=inflections, replace=False)) + inflection_indices = np.append(inflection_indices, tensor.shape[0]) + inflection_indices = np.insert(inflection_indices, 0, 0) + else: + inflection_indices = np.arange(inflections+2) * int(tensor.shape[0] / (inflections+1)) + + for idx in range(len(inflection_indices)-1): + start_idx = inflection_indices[idx] + stop_idx = inflection_indices[idx+1] + duration = stop_idx - start_idx + start_power = noise_power_db_low if idx%2 == 0 else noise_power_db_high + stop_power = noise_power_db_high if idx%2 == 0 else noise_power_db_low + noise_power_db[start_idx:stop_idx] = np.linspace(start_power, stop_power, duration) + + return tensor + (10.0**(noise_power_db/20.0))*(real_noise + 1j*imag_noise)/np.sqrt(2) + + +def rayleigh_fading( + tensor: np.ndarray, + coherence_bandwidth: float, + power_delay_profile: np.ndarray, +) -> np.ndarray: + """Applies Rayleigh fading channel to tensor. Taps are generated by + interpolating and filtering Gaussian taps. + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + coherence_bandwidth (:obj:`float`): + coherence_bandwidth relative to the sample rate in [0, 1.0] + + power_delay_profile (:obj:`float`): + power_delay_profile assigned to channel + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone Rayleigh Fading. + + """ + num_taps = int(np.ceil(1.0 / coherence_bandwidth)) # filter length to get desired coherence bandwidth + power_taps = np.sqrt(np.interp( + np.linspace(0, 1.0, 100*num_taps), + np.linspace(0, 1.0, len(power_delay_profile)), + power_delay_profile + )) + # Generate initial taps + rayleigh_taps = (np.random.randn(num_taps) + 1j * np.random.randn(num_taps)) # multi-path channel + + # Linear interpolate taps by a factor of 100 -- so we can get accurate coherence bandwidths + old_time = np.linspace(0, 1.0, num_taps, endpoint=True) + real_tap_function = interpolate.interp1d(old_time, rayleigh_taps.real) + imag_tap_function = interpolate.interp1d(old_time, rayleigh_taps.imag) + + new_time = np.linspace(0, 1.0, 100*num_taps, endpoint=True) + rayleigh_taps = real_tap_function(new_time) + 1j*imag_tap_function(new_time) + rayleigh_taps *= power_taps + + # Ensure that we maintain the same amount of power before and after the transform + input_power = np.linalg.norm(tensor) + tensor = sp.upfirdn(rayleigh_taps, tensor, up=100, down=100)[-tensor.shape[0]:] + output_power = np.linalg.norm(tensor) + tensor = np.multiply(input_power/output_power, tensor) + return tensor + + +def phase_offset(tensor: np.ndarray, phase: float) -> np.ndarray: + """ Applies a phase rotation to tensor + + Args: + tensor: (:class:`numpy.ndarray`): + (batch_size, vector_length, ...)-sized tensor. + + phase (:obj:`float`): + phase to rotate sample in [-pi, pi] + + Returns: + transformed (:class:`numpy.ndarray`): + Tensor that has undergone a phase rotation + + """ + return tensor*np.exp(1j*phase) diff --git a/torchsig/transforms/wireless_channel/wce.py b/torchsig/transforms/wireless_channel/wce.py index 851e931..476d9ff 100644 --- a/torchsig/transforms/wireless_channel/wce.py +++ b/torchsig/transforms/wireless_channel/wce.py @@ -1,10 +1,10 @@ -from copy import deepcopy import numpy as np +from copy import deepcopy from typing import Optional, Tuple, List, Union, Any from torchsig.utils.types import SignalData, SignalDescription from torchsig.transforms.transforms import SignalTransform -from torchsig.transforms.wireless_channel import wce_functional as F +from torchsig.transforms.wireless_channel import functional as F from torchsig.transforms.functional import NumericParameter, FloatParameter, IntParameter from torchsig.transforms.functional import to_distribution, uniform_continuous_distribution, uniform_discrete_distribution @@ -81,11 +81,11 @@ def __call__(self, data: Any) -> Any: class AddNoise(SignalTransform): - """ Add random AWGN at specified power levels + """Add random AWGN at specified power levels Note: - Differs from the TargetSNR() transform in that this transform adds - noise at a specified power level, whereas AddNoise() + Differs from the TargetSNR() in that this transform adds + noise at a specified power level, whereas TargetSNR() assumes a basebanded signal and adds noise to achieve a specified SNR level for the signal of interest. This transform, AddNoise() is useful for simply adding a randomized @@ -100,6 +100,9 @@ class AddNoise(SignalTransform): * If int or float, target_snr is fixed at the value provided * If list, target_snr is any element in the list * If tuple, target_snr is in range of (tuple[0], tuple[1]) + + input_noise_floor_db (:obj:`float`): + The noise floor of the input data in dB linear (:obj:`bool`): If True, target_snr and signal_power is on linear scale not dB. @@ -107,18 +110,19 @@ class AddNoise(SignalTransform): Example: >>> import torchsig.transforms as ST >>> # Added AWGN power range is (-40, -20) dB - >>> transform = ST.AddNoiseTransform((-40, -20)) + >>> transform = ST.AddRandomNoiseTransform((-40, -20)) """ - def __init__( self, - noise_power_db : NumericParameter = uniform_continuous_distribution(-80, -60), + noise_power_db: NumericParameter = uniform_continuous_distribution(-80, -60), + input_noise_floor_db: float = 0.0, linear: Optional[bool] = False, **kwargs, ): super(AddNoise, self).__init__(**kwargs) - self.noise_power_db = to_distribution(noise_power_db) + self.noise_power_db = to_distribution(noise_power_db, self.random_generator) + self.input_noise_floor_db = input_noise_floor_db self.linear = linear def __call__(self, data: Any) -> Any: @@ -131,9 +135,17 @@ def __call__(self, data: Any) -> Any: signal_description=[], ) - # Apply data augmentation + # Retrieve random noise power value noise_power_db = self.noise_power_db() noise_power_db = 10*np.log10(noise_power_db) if self.linear else noise_power_db + + if self.input_noise_floor_db: + noise_floor = self.input_noise_floor_db + else: + # TODO: implement fast noise floor estimation technique? + noise_floor = 0 # Assumes 0dB noise floor + + # Apply data augmentation new_data.iq_data = F.awgn(data.iq_data, noise_power_db) # Update SignalDescription @@ -141,7 +153,7 @@ def __call__(self, data: Any) -> Any: signal_description = [data.signal_description] if isinstance(data.signal_description, SignalDescription) else data.signal_description for signal_desc in signal_description: new_signal_desc = deepcopy(signal_desc) - new_signal_desc.snr -= noise_power_db + new_signal_desc.snr = (new_signal_desc.snr - noise_power_db) if noise_power_db > noise_floor else new_signal_desc.snr new_signal_description.append(new_signal_desc) new_data.signal_description = new_signal_description diff --git a/torchsig/utils/visualize.py b/torchsig/utils/visualize.py index f81ec71..da3c78c 100644 --- a/torchsig/utils/visualize.py +++ b/torchsig/utils/visualize.py @@ -1,10 +1,11 @@ import pywt import numpy as np +from copy import deepcopy from scipy import ndimage from scipy import signal as sp from matplotlib import pyplot as plt from matplotlib.figure import Figure -from torch.utils.data import DataLoader +from torch.utils.data import dataloader from typing import Optional, Callable, Iterable, Union, Tuple, List @@ -24,7 +25,7 @@ class Visualizer: """ def __init__( self, - data_loader: DataLoader, + data_loader: dataloader, visualize_transform: Optional[Callable] = None, visualize_target_transform: Optional[Callable] = None ): @@ -278,6 +279,346 @@ def _visualize(self, data: np.ndarray, targets: np.ndarray) -> Figure: return figure + +class PSDVisualizer(Visualizer): + """ Visualize a PSD + + Args: + fft_size: + **kwargs: + """ + + def __init__(self, fft_size: int = 1024, **kwargs): + super(PSDVisualizer, self).__init__(**kwargs) + self.fft_size = fft_size + + def _visualize(self, iq_data: np.ndarray, targets: np.ndarray) -> Figure: + batch_size = iq_data.shape[0] + figure = plt.figure() + for sample_idx in range(batch_size): + plt.subplot(int(np.ceil(np.sqrt(batch_size))), + int(np.sqrt(batch_size)), sample_idx + 1) + Pxx, freqs = plt.psd(iq_data[sample_idx], NFFT=self.fft_size, Fs=1) + plt.xticks() + plt.yticks() + plt.title(str(targets[sample_idx])) + return figure + + +class MaskVisualizer(Visualizer): + """ Visualize data with mask label information overlaid + + Args: + **kwargs: + """ + def __init__(self, **kwargs): + super(MaskVisualizer, self).__init__(**kwargs) + + def __next__(self) -> Figure: + iq_data, targets = next(self.data_iter) + if self.visualize_transform: + iq_data = self.visualize_transform(deepcopy(iq_data)) + + if self.visualize_target_transform: + targets = self.visualize_target_transform(deepcopy(targets)) + else: + targets = None + + return self._visualize(iq_data, targets) + + def _visualize(self, data: np.ndarray, targets: np.ndarray) -> Figure: + batch_size = data.shape[0] + figure = plt.figure(frameon=False) + for sample_idx in range(batch_size): + plt.subplot(int(np.ceil(np.sqrt(batch_size))), + int(np.sqrt(batch_size)), sample_idx + 1) + extent = 0, data.shape[1], 0, data.shape[2] + data_img = plt.imshow( + data[sample_idx], + vmin=np.min(data[sample_idx]), + vmax=np.max(data[sample_idx]), + cmap="jet", + extent=extent, + ) + if targets is not None: + label = targets[sample_idx] + label_img = plt.imshow( + label, + vmin=np.min(label), + vmax=np.max(label), + cmap="gray", + alpha=0.5, + interpolation="none", + extent=extent, + ) + plt.xticks([]) + plt.yticks([]) + plt.title("Data") + + return figure + + +class MaskClassVisualizer(Visualizer): + """ + Visualize data with mask label information overlaid and the class of the + mask included in the title + + Args: + **kwargs: + """ + def __init__(self, class_list, **kwargs): + super(MaskClassVisualizer, self).__init__(**kwargs) + self.class_list = class_list + + def __next__(self) -> Figure: + iq_data, targets = next(self.data_iter) + if self.visualize_transform: + iq_data = self.visualize_transform(deepcopy(iq_data)) + + if self.visualize_target_transform: + classes, targets = self.visualize_target_transform(deepcopy(targets)) + else: + targets = None + + return self._visualize(iq_data, targets, classes) + + def _visualize(self, data: np.ndarray, targets: np.ndarray, classes: List) -> Figure: + batch_size = data.shape[0] + figure = plt.figure(frameon=False) + for sample_idx in range(batch_size): + plt.subplot(int(np.ceil(np.sqrt(batch_size))), + int(np.sqrt(batch_size)), sample_idx + 1) + extent = 0, data.shape[1], 0, data.shape[2] + data_img = plt.imshow( + data[sample_idx], + vmin=np.min(data[sample_idx]), + vmax=np.max(data[sample_idx]), + cmap="jet", + extent=extent, + ) + title = [] + if targets is not None: + class_idx = classes[sample_idx] + mask = targets[sample_idx] + mask_img = plt.imshow( + mask, + vmin=np.min(mask), + vmax=np.max(mask), + cmap="gray", + alpha=0.5, + interpolation="none", + extent=extent, + ) + title = [self.class_list[idx] for idx in class_idx] + else: + title = "Data" + plt.xticks([]) + plt.yticks([]) + plt.title(title) + + return figure + + +class SemanticMaskClassVisualizer(Visualizer): + """ + Visualize data with mask label information overlaid and the class of the + mask included in the title + + Args: + **kwargs: + """ + def __init__(self, class_list, **kwargs): + super(SemanticMaskClassVisualizer, self).__init__(**kwargs) + self.class_list = class_list + + def __next__(self) -> Figure: + iq_data, targets = next(self.data_iter) + if self.visualize_transform: + iq_data = self.visualize_transform(deepcopy(iq_data)) + + if self.visualize_target_transform: + targets = self.visualize_target_transform(deepcopy(targets)) + + return self._visualize(iq_data, targets) + + def _visualize(self, data: np.ndarray, targets: np.ndarray) -> Figure: + batch_size = data.shape[0] + figure = plt.figure(frameon=False) + for sample_idx in range(batch_size): + plt.subplot(int(np.ceil(np.sqrt(batch_size))), + int(np.sqrt(batch_size)), sample_idx + 1) + extent = 0, data.shape[1], 0, data.shape[2] + data_img = plt.imshow( + data[sample_idx], + vmin=np.min(data[sample_idx]), + vmax=np.max(data[sample_idx]), + cmap="jet", + extent=extent, + ) + title = [] + if targets is not None: + mask = np.ma.masked_where(targets[sample_idx] < 1, targets[sample_idx]) + mask_img = plt.imshow( + mask, + alpha=0.5, + interpolation="none", + extent=extent, + ) + classes_present = list(set(targets[sample_idx].flatten().tolist())) + classes_present.remove(0.0) # Remove 'background' class + title = [self.class_list[int(class_idx-1)] for class_idx in classes_present] + else: + title = "Data" + plt.xticks([]) + plt.yticks([]) + plt.title(title) + + return figure + + +class BoundingBoxVisualizer(Visualizer): + """ Visualize data with bounding box label information overlaid + + Args: + **kwargs: + """ + def __init__(self, **kwargs): + super(BoundingBoxVisualizer, self).__init__(**kwargs) + + def __next__(self) -> Figure: + iq_data, targets = next(self.data_iter) + + if self.visualize_transform: + iq_data = self.visualize_transform(deepcopy(iq_data)) + + if self.visualize_target_transform: + targets = self.visualize_target_transform(deepcopy(targets)) + else: + targets = targets + + return self._visualize(iq_data, targets) + + def _visualize(self, data: np.ndarray, targets: np.ndarray) -> Figure: + batch_size = data.shape[0] + figure = plt.figure(frameon=False) + for sample_idx in range(batch_size): + ax = plt.subplot(int(np.ceil(np.sqrt(batch_size))), + int(np.sqrt(batch_size)), sample_idx + 1) + + # Retrieve individual label + ax.imshow( + data[sample_idx], + vmin=np.min(data[sample_idx]), + vmax=np.max(data[sample_idx]), + cmap="jet", + ) + label = targets[sample_idx] + pixels_per_cell_x = data[sample_idx].shape[0] / label.shape[0] + pixels_per_cell_y = data[sample_idx].shape[1] / label.shape[1] + + for grid_cell_x_idx in range(label.shape[0]): + for grid_cell_y_idx in range(label.shape[1]): + if label[grid_cell_x_idx, grid_cell_y_idx, 0] == 1: + duration = label[grid_cell_x_idx, grid_cell_y_idx, 2]*data[sample_idx].shape[0] + bandwidth = label[grid_cell_x_idx, grid_cell_y_idx, 4]*data[sample_idx].shape[1] + start_pixel = (grid_cell_x_idx*pixels_per_cell_x) + (label[grid_cell_x_idx, grid_cell_y_idx, 1]*pixels_per_cell_x) - duration/2 + low_freq = (grid_cell_y_idx*pixels_per_cell_y) + (label[grid_cell_x_idx, grid_cell_y_idx, 3]*pixels_per_cell_y) \ + - (label[grid_cell_x_idx, grid_cell_y_idx, 4]/2 * data[sample_idx].shape[1]) + + rect = patches.Rectangle( + (start_pixel,low_freq), + duration, + bandwidth, # Bandwidth (pixels) + linewidth=3, + edgecolor='b', + facecolor='none' + ) + ax.add_patch(rect) + plt.imshow(data[sample_idx], aspect='auto', cmap="jet",vmin=np.min(data[sample_idx]),vmax=np.max(data[sample_idx])) + plt.xticks([]) + plt.yticks([]) + plt.title("Data") + + return figure + + +class AnchorBoxVisualizer(Visualizer): + """ Visualize data with anchor box label information overlaid + + Args: + **kwargs: + """ + def __init__( + self, + data_loader: dataloader, + visualize_transform: Optional[Callable] = None, + visualize_target_transform: Optional[Callable] = None, + anchor_boxes: List = None, + ): + self.data_loader = iter(data_loader) + self.visualize_transform = visualize_transform + self.visualize_target_transform = visualize_target_transform + self.anchor_boxes = anchor_boxes + self.num_anchor_boxes = len(anchor_boxes) + + def __next__(self) -> Figure: + iq_data, targets = next(self.data_iter) + + if self.visualize_transform: + iq_data = self.visualize_transform(deepcopy(iq_data)) + + if self.visualize_target_transform: + targets = self.visualize_target_transform(deepcopy(targets)) + else: + targets = targets + + return self._visualize(iq_data, targets) + + def _visualize(self, data: np.ndarray, targets: np.ndarray) -> Figure: + batch_size = data.shape[0] + figure = plt.figure(frameon=False) + for sample_idx in range(batch_size): + ax = plt.subplot(int(np.ceil(np.sqrt(batch_size))), + int(np.sqrt(batch_size)), sample_idx + 1) + + # Retrieve individual label + ax.imshow( + data[sample_idx], + vmin=np.min(data[sample_idx]), + vmax=np.max(data[sample_idx]), + cmap="jet", + ) + label = targets[sample_idx] + pixels_per_cell_x = data[sample_idx].shape[0] / label.shape[0] + pixels_per_cell_y = data[sample_idx].shape[1] / label.shape[1] + + for grid_cell_x_idx in range(label.shape[0]): + for grid_cell_y_idx in range(label.shape[1]): + for anchor_idx in range(self.num_anchor_boxes): + if label[grid_cell_x_idx, grid_cell_y_idx, 0+5*anchor_idx] == 1: + duration = label[grid_cell_x_idx, grid_cell_y_idx, 2+5*anchor_idx]*self.anchor_boxes[anchor_idx][0]*data[sample_idx].shape[0] + bandwidth = label[grid_cell_x_idx, grid_cell_y_idx, 4+5*anchor_idx]*self.anchor_boxes[anchor_idx][1]*data[sample_idx].shape[1] + start_pixel = (grid_cell_x_idx*pixels_per_cell_x) + (label[grid_cell_x_idx, grid_cell_y_idx, 1+5*anchor_idx]*pixels_per_cell_x) - duration/2 + low_freq = (grid_cell_y_idx*pixels_per_cell_y) + (label[grid_cell_x_idx, grid_cell_y_idx, 3+5*anchor_idx]*pixels_per_cell_y) \ + - (label[grid_cell_x_idx, grid_cell_y_idx, 4+5*anchor_idx]*self.anchor_boxes[anchor_idx][1]/2 * data[sample_idx].shape[1]) + + rect = patches.Rectangle( + (start_pixel,low_freq), + duration, + bandwidth, # Bandwidth (pixels) + linewidth=3, + edgecolor='b', + facecolor='none' + ) + ax.add_patch(rect) + + plt.imshow(data[sample_idx], aspect='auto', cmap="jet",vmin=np.min(data[sample_idx]),vmax=np.max(data[sample_idx])) + plt.xticks([]) + plt.yticks([]) + plt.title("Data") + + return figure + ############################################################################### # Visualizer Transform Functions @@ -358,7 +699,7 @@ def onehot_label_format(tensor: np.ndarray) -> List[str]: return label -def multihot_label_format(tensor: np.ndarray, class_list: List[str]) -> List[List[str]]: +def multihot_label_format(tensor: np.ndarray, class_list: List[str]) -> List[str]: """Target Transform: Format multihot labels for titles in visualizer """ @@ -371,3 +712,87 @@ def multihot_label_format(tensor: np.ndarray, class_list: List[str]) -> List[Lis curr_label.append(class_list[class_idx]) label.append(curr_label) return label + + +def mask_to_outline(tensor: np.ndarray) -> List[str]: + """Target Transform: Transforms masks for all bursts to outlines for the + MaskVisualizer. Overlapping mask outlines are represented as a single + polygon. + + """ + batch_size = tensor.shape[0] + labels = [] + struct = ndimage.generate_binary_structure(2,2) + for idx in range(batch_size): + label = tensor[idx].numpy() + label = np.sum(label, axis=0) + label[label>0] = 1 + label = label - ndimage.binary_erosion(label) + label = ndimage.binary_dilation(label, structure=struct, iterations=3).astype(label.dtype) + label = np.ma.masked_where(label == 0, label) + labels.append(label) + return labels + + +def mask_to_outline_overlap(tensor: np.ndarray) -> List[str]: + """Target Transform: Transforms masks for each burst to individual outlines + for the MaskVisualizer. Overlapping mask outlines are still shown as + overlapping. + + """ + batch_size = tensor.shape[0] + labels = [] + struct = ndimage.generate_binary_structure(2,2) + for idx in range(batch_size): + label = tensor[idx].numpy() + for individual_burst_idx in range(label.shape[0]): + label[individual_burst_idx] = label[individual_burst_idx] - \ + ndimage.binary_erosion(label[individual_burst_idx]) + label = np.sum(label, axis=0) + label[label>0] = 1 + label = ndimage.binary_dilation(label, structure=struct, iterations=2).astype(label.dtype) + label = np.ma.masked_where(label == 0, label) + labels.append(label) + return labels + + +def overlay_mask(tensor: np.ndarray) -> List[str]: + """Target Transform: Transforms multi-dimensional mask to binary overlay of + full mask. + + """ + batch_size = tensor.shape[0] + labels = [] + for idx in range(batch_size): + label = torch.sum(tensor[idx], axis=0).numpy() + label[label>0] = 1 + label = np.ma.masked_where(label == 0, label) + labels.append(label) + return labels + + +def mask_class_to_outline(tensor: np.ndarray) -> List[str]: + """Target Transform: Transforms masks for each burst to individual outlines + for the MaskClassVisualizer. Overlapping mask outlines are still shown as + overlapping. Each bursts' class index is also returned. + + """ + batch_size = tensor.shape[0] + labels = [] + class_idx = [] + struct = ndimage.generate_binary_structure(2,2) + for idx in range(batch_size): + label = tensor[idx].numpy() + class_idx_curr = [] + for individual_burst_idx in range(label.shape[0]): + if np.count_nonzero(label[individual_burst_idx]) > 0: + class_idx_curr.append(individual_burst_idx) + label[individual_burst_idx] = label[individual_burst_idx] - \ + ndimage.binary_erosion(label[individual_burst_idx]) + label = np.sum(label, axis=0) + label[label>0] = 1 + label = ndimage.binary_dilation(label, structure=struct, iterations=2).astype(label.dtype) + label = np.ma.masked_where(label == 0, label) + class_idx.append(class_idx_curr) + labels.append(label) + return class_idx, labels diff --git a/torchsig/version.py b/torchsig/version.py new file mode 100644 index 0000000..541f859 --- /dev/null +++ b/torchsig/version.py @@ -0,0 +1 @@ +__version__ = '0.1.0' \ No newline at end of file