diff --git a/examples/01_example_modulations_dataset.ipynb b/examples/01_example_modulations_dataset.ipynb index 004c153..214602e 100644 --- a/examples/01_example_modulations_dataset.ipynb +++ b/examples/01_example_modulations_dataset.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "id": "f5634817-932d-4709-beb6-e50c11ffbc81", "metadata": {}, "outputs": [], @@ -36,7 +36,8 @@ "import pytorch_lightning as pl\n", "import numpy as np\n", "import pickle\n", - "import lmdb" + "import lmdb\n", + "import os" ] }, { @@ -55,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "id": "c01651a5-904a-4fb3-bdbf-f826615b977f", "metadata": {}, "outputs": [ @@ -176,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "id": "160b0f82-28d7-47a9-9bde-0d5897093994", "metadata": {}, "outputs": [], @@ -204,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "id": "61f278a5-7b85-460f-b3a1-ae00a8fa8317", "metadata": {}, "outputs": [ @@ -233,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "id": "932a982c-9ed1-4d31-93f0-f66a59cac90a", "metadata": {}, "outputs": [ @@ -273,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "id": "22b3d234-bbe7-488b-a904-f1263e727554", "metadata": {}, "outputs": [ @@ -281,11 +282,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5300/5300 [01:55<00:00, 45.87it/s] \n" + "100%|██████████| 5300/5300 [02:25<00:00, 36.50it/s] \n" ] } ], "source": [ + "os.makedirs(\"./datasets/01_dataset\", exist_ok=True)\n", "env = lmdb.open(\"./datasets/01_dataset\", max_dbs=3 if include_snr else 2, map_size=int(1e12))\n", "\n", "iq_sample_db = env.open_db(\"iq_samples\".encode())\n", diff --git a/examples/03_example_widebandsig53_dataset.ipynb b/examples/03_example_widebandsig53_dataset.ipynb index 2114ac7..f3e21fb 100644 --- a/examples/03_example_widebandsig53_dataset.ipynb +++ b/examples/03_example_widebandsig53_dataset.ipynb @@ -89,7 +89,7 @@ "source": [ "# Generate WidebandSig53 DataModule\n", "from torchsig.transforms import *\n", - "root = \"./datasets/wideband_sig53\"\n", + "root = \"../datasets/wideband_sig53\"\n", "impaired = True\n", "qa = True\n", "fft_size = 512\n", diff --git a/examples/06_example_wideband_yolo.ipynb b/examples/06_example_wideband_yolo.ipynb index 844a762..d1d2135 100644 --- a/examples/06_example_wideband_yolo.ipynb +++ b/examples/06_example_wideband_yolo.ipynb @@ -25,29 +25,112 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "ab949825-7c48-44f2-852d-56567f5952e5", "metadata": {}, "outputs": [], "source": [ - "from ultralytics import YOLO\n", - "from torchsig.utils.yolo_train import *" + "# Packages Imports for Training\n", + "from torchsig.utils.yolo_train import *\n", + "from datetime import datetime\n", + "import yaml" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "b4bff6d5-4b2d-4db2-97a0-f45843e7cc60", "metadata": { "tags": [] }, "outputs": [], "source": [ - "from torchsig.datasets.wideband_sig53 import WidebandSig53\n", + "# Package Imports for Testing/Inference\n", + "from torchsig.datasets.datamodules import WidebandSig53DataModule\n", "from torchsig.transforms.transforms import Spectrogram, SpectrogramImage, Normalize, Compose, Identity\n", + "from torchsig.transforms.target_transforms import DescToBBoxFamilyDict\n", "from ultralytics import YOLO\n", - "from PIL import Image\n", - "import numpy as np" + "from PIL import Image" + ] + }, + { + "cell_type": "markdown", + "id": "efea64b7-1d22-41bd-81cc-5c39a74c3bdd", + "metadata": {}, + "source": [ + "-----------------------------\n", + "## Check or Generate the Wideband Sig53 Dataset\n", + "To generate the WidebandSig53 dataset, several parameters are given to the imported `WidebandSig53DataModule` 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", + "- `qa` - A boolean to specify whether to generate a small subset of Sig53 (True), or the full dataset (False), default is True\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", + "\n", + "A combination of the `train` and the `impaired` booleans determines which of the four (4) distinct WidebandSig53 datasets will be instantiated:\n", + "| `impaired` | `qa` | Result |\n", + "| ---------- | ---- | ------- |\n", + "| `False` | `False` | Clean datasets of train=250k examples and val=25k examples |\n", + "| `False` | `True` | Clean datasets of train=250 examples and val=250 examples |\n", + "| `True` | `False` | Impaired datasets of train=250k examples and val=25k examples |\n", + "| `True` | `True` | Impaired datasets of train=250 examples and val=250 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": null, + "id": "ca6e8bfb-92f3-4615-afac-7568350a2461", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate WidebandSig53 DataModule\n", + "root = \"../datasets/wideband_sig53\"\n", + "impaired = True\n", + "qa = True\n", + "fft_size = 512\n", + "num_classes = 53\n", + "batch_size = 1\n", + "\n", + "transform = Compose([ \n", + "])\n", + "\n", + "target_transform = Compose([\n", + " DescToBBoxFamilyDict()\n", + "])\n", + "\n", + "datamodule = WidebandSig53DataModule(\n", + " root=root,\n", + " impaired=impaired,\n", + " qa=qa,\n", + " fft_size=fft_size,\n", + " num_classes=num_classes,\n", + " transform=transform,\n", + " target_transform=target_transform,\n", + " batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2964745c-4fda-4cdc-93ce-6ac67a5e1da8", + "metadata": {}, + "outputs": [], + "source": [ + "datamodule.prepare_data()\n", + "datamodule.setup(\"fit\")\n", + "\n", + "wideband_sig53 = datamodule.train\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: {}\".format(label))" ] }, { @@ -72,46 +155,44 @@ "source": [ "### Explanation of the `overrides` Dictionary\n", "\n", - "The `overrides` dictionary is used to customize the settings for the Ultralytics YOLO trainer by specifying specific values that override the default configurations. Below is a breakdown of the dictionary:\n", + "The `overrides` dictionary is used to customize the settings for the Ultralytics YOLO trainer by specifying specific values that override the default configurations. The dictionary is imported from `wbdata.yaml`. However, you can customize in the notebook. \n", + "\n", + "Example:\n", "\n", "```python\n", - "overrides = {\n", - " 'model': 'yolov8n.pt',\n", - " 'epochs': 100,\n", - " 'imgsz': 512,\n", - " 'data': 'wbdata.yaml',\n", - " 'device': 0, \n", - " 'single_cls': True\n", - "}\n", + "overrides = {'model': 'yolov8n.pt', 'epochs': 100, 'data': 'wbdata.yaml', 'device': 0, 'imgsz': 512, 'single_cls': True}\n", "```\n", - "A .yaml is necessary for training. Look at wbdata.yaml in the examples directory. It will contain the path to your torchsig data." + "A .yaml is necessary for training. Look at `wbdata.yaml` in the examples directory. It will contain the path to your torchsig data.\n", + "\n", + "\n", + "### Dataset Location Warning\n", + "\n", + "There must exist a datasets directory at `/path/to/torchsig/datasets`.\n", + "\n", + "This example assumes that you have generated `train` and `val` lmdb wideband datasets at `../datasets/wideband_sig53/`\n", + "\n", + "You can also specify an absolute path to your dataset in `wbdata.yaml`." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "cc6137ed-44f5-4dd3-a16c-0267a84bfe55", "metadata": {}, "outputs": [], "source": [ - "overrides = {'model': 'yolov8n.pt', 'epochs': 5, 'imgsz': 512, 'data': 'wbdata.yaml', 'device': 0, 'single_cls': True}" + "with open('wbdata.yaml', 'r') as file:\n", + " config = yaml.safe_load(file)\n", + "overrides = config['overrides']\n", + "print(f\"Creating experiment -> {overrides['name']}\")" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "6a6f0586-c1d5-4230-b9a4-4f9e6413c635", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ultralytics YOLOv8.2.82 🚀 Python-3.10.12 torch-2.4.0+cu121 CUDA:0 (NVIDIA A100-SXM4-80GB, 81038MiB)\n", - "\u001b[34m\u001b[1mengine/trainer: \u001b[0mtask=detect, mode=train, model=yolov8n.pt, data=wbdata.yaml, epochs=5, time=None, patience=100, batch=16, imgsz=512, save=True, save_period=-1, cache=False, device=0, workers=8, project=None, name=train2, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=True, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, opset=None, workspace=4, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs/detect/train2\n" - ] - } - ], + "outputs": [], "source": [ "trainer = Yolo_Trainer(overrides=overrides)" ] @@ -129,249 +210,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "ad7e5f57-3b5b-4074-b87c-6e18c7b973af", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Overriding model.yaml nc=80 with nc=53\n", - "\n", - " from n params module arguments \n", - " 0 -1 1 464 ultralytics.nn.modules.conv.Conv [3, 16, 3, 2] \n", - " 1 -1 1 4672 ultralytics.nn.modules.conv.Conv [16, 32, 3, 2] \n", - " 2 -1 1 7360 ultralytics.nn.modules.block.C2f [32, 32, 1, True] \n", - " 3 -1 1 18560 ultralytics.nn.modules.conv.Conv [32, 64, 3, 2] \n", - " 4 -1 2 49664 ultralytics.nn.modules.block.C2f [64, 64, 2, True] \n", - " 5 -1 1 73984 ultralytics.nn.modules.conv.Conv [64, 128, 3, 2] \n", - " 6 -1 2 197632 ultralytics.nn.modules.block.C2f [128, 128, 2, True] \n", - " 7 -1 1 295424 ultralytics.nn.modules.conv.Conv [128, 256, 3, 2] \n", - " 8 -1 1 460288 ultralytics.nn.modules.block.C2f [256, 256, 1, True] \n", - " 9 -1 1 164608 ultralytics.nn.modules.block.SPPF [256, 256, 5] \n", - " 10 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] \n", - " 11 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1] \n", - " 12 -1 1 148224 ultralytics.nn.modules.block.C2f [384, 128, 1] \n", - " 13 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] \n", - " 14 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1] \n", - " 15 -1 1 37248 ultralytics.nn.modules.block.C2f [192, 64, 1] \n", - " 16 -1 1 36992 ultralytics.nn.modules.conv.Conv [64, 64, 3, 2] \n", - " 17 [-1, 12] 1 0 ultralytics.nn.modules.conv.Concat [1] \n", - " 18 -1 1 123648 ultralytics.nn.modules.block.C2f [192, 128, 1] \n", - " 19 -1 1 147712 ultralytics.nn.modules.conv.Conv [128, 128, 3, 2] \n", - " 20 [-1, 9] 1 0 ultralytics.nn.modules.conv.Concat [1] \n", - " 21 -1 1 493056 ultralytics.nn.modules.block.C2f [384, 256, 1] \n", - " 22 [15, 18, 21] 1 761647 ultralytics.nn.modules.head.Detect [53, [64, 128, 256]] \n", - "Model summary: 225 layers, 3,021,183 parameters, 3,021,167 gradients, 8.3 GFLOPs\n", - "\n", - "Transferred 319/355 items from pretrained weights\n", - "Freezing layer 'model.22.dfl.conv.weight'\n", - "\u001b[34m\u001b[1mAMP: \u001b[0mrunning Automatic Mixed Precision (AMP) checks with YOLOv8n...\n", - "\u001b[34m\u001b[1mAMP: \u001b[0mchecks passed ✅\n", - "Loading label caches from /weka/pvallance/git_clones/torchsig-internal-dev/examples/datasets/wideband_sig53\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py:268: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n", - " self.scaler = torch.cuda.amp.GradScaler(enabled=self.amp)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading label caches from /weka/pvallance/git_clones/torchsig-internal-dev/examples/datasets/wideband_sig53\n", - "Plotting labels to runs/detect/train2/labels.jpg... \n", - "\u001b[34m\u001b[1moptimizer:\u001b[0m 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... \n", - "\u001b[34m\u001b[1moptimizer:\u001b[0m AdamW(lr=0.000175, momentum=0.9) with parameter groups 57 weight(decay=0.0), 64 weight(decay=0.0005), 63 bias(decay=0.0)\n", - "Image sizes 512 train, 512 val\n", - "Using 8 dataloader workers\n", - "Logging results to \u001b[1mruns/detect/train2\u001b[0m\n", - "Starting training for 5 epochs...\n", - "\n", - " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 1/5 1.49G 2.214 5.045 1.82 55 512: 100%|██████████| 16/16 [00:01<00:00, 8.63it/s]\n", - " Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 8/8 [00:00<00:00, 16.32it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " all 250 1061 0 0 0 0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 2/5 1.47G 1.953 4.921 1.643 62 512: 100%|██████████| 16/16 [00:01<00:00, 14.89it/s]\n", - " Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 8/8 [00:00<00:00, 19.97it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " all 250 1061 0 0 0 0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 3/5 1.53G 1.874 4.655 1.545 52 512: 100%|██████████| 16/16 [00:01<00:00, 15.15it/s]\n", - " Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 8/8 [00:00<00:00, 19.61it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " all 250 1061 1 0.00189 0.501 0.401\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4/5 1.51G 1.695 4.168 1.455 66 512: 100%|██████████| 16/16 [00:01<00:00, 15.41it/s]\n", - " Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 8/8 [00:00<00:00, 16.44it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " all 250 1061 0.603 0.066 0.339 0.2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5/5 1.51G 1.632 3.842 1.379 57 512: 100%|██████████| 16/16 [00:01<00:00, 15.80it/s]\n", - " Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 8/8 [00:00<00:00, 13.63it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " all 250 1061 0.499 0.228 0.359 0.229\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "5 epochs completed in 0.003 hours.\n", - "Optimizer stripped from runs/detect/train2/weights/last.pt, 6.2MB\n", - "Optimizer stripped from runs/detect/train2/weights/best.pt, 6.2MB\n", - "\n", - "Validating runs/detect/train2/weights/best.pt...\n", - "Ultralytics YOLOv8.2.82 🚀 Python-3.10.12 torch-2.4.0+cu121 CUDA:0 (NVIDIA A100-SXM4-80GB, 81038MiB)\n", - "Model summary (fused): 168 layers, 3,015,983 parameters, 0 gradients, 8.1 GFLOPs\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 8/8 [00:00<00:00, 10.05it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " all 250 1061 1 0.00189 0.501 0.401\n", - " ook 250 1061 1 0.00189 0.501 0.401\n", - "Speed: 0.1ms preprocess, 2.0ms inference, 0.0ms loss, 0.1ms postprocess per image\n", - "Results saved to \u001b[1mruns/detect/train2\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ "trainer.train()" ] @@ -396,36 +240,57 @@ "id": "c45fa7bf-fa7d-4896-9022-4e608d93e5a4", "metadata": {}, "source": [ - "## Instantiate WBSig53 Dataset\n", - "After generating the WBSig53 dataset (see `03_example_widebandsig53_dataset.ipynb`), we can instantiate it with the needed transforms. Change `root` to dataset path.\n", + "## Generate and Instantiate WBSig53 Test Dataset\n", + "After generating the WBSig53 dataset (see `03_example_widebandsig53_dataset.ipynb`), we can instantiate it with the needed transforms. Change `root` to test dataset path.\n", "\n", "---" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "694c33f1-d718-40ae-861d-26c3431a6f41", "metadata": {}, "outputs": [], "source": [ - "test_path = './datasets/wideband_sig53'\n", + "test_path = '../datasets/wideband_sig53_test' #Should differ from your training dataset\n", "\n", "transform = Compose([\n", " Spectrogram(nperseg=512, noverlap=0, nfft=512, mode='psd'),\n", " Normalize(norm=np.inf, flatten=True),\n", " SpectrogramImage(), \n", " ])\n", - "target_transform = Compose([\n", - " ])\n", "\n", - "test_dataset = WidebandSig53(\n", - " root=test_path, \n", - " train=True, \n", - " impaired=True,\n", - " transform=transform,\n", - " target_transform=target_transform\n", - " )" + "test_data = WidebandSig53DataModule(\n", + " root=test_path,\n", + " impaired=impaired,\n", + " qa=qa,\n", + " fft_size=fft_size,\n", + " num_classes=num_classes,\n", + " transform=transform,\n", + " target_transform=None,\n", + " batch_size=batch_size\n", + ")\n", + "\n", + "test_data.prepare_data()\n", + "test_data.setup(\"fit\")\n", + "\n", + "wideband_sig53_test = test_data.train\n", + "\n", + "# Retrieve a sample and print out information\n", + "idx = np.random.randint(len(wideband_sig53_test))\n", + "data, label = wideband_sig53_test[idx]\n", + "print(\"Dataset length: {}\".format(len(wideband_sig53_test)))\n", + "print(\"Data shape: {}\".format(data.shape))\n", + "\n", + "samples = []\n", + "labels = []\n", + "for i in range(10):\n", + " idx = np.random.randint(len(wideband_sig53_test))\n", + " sample, label = wideband_sig53_test[idx]\n", + " lb = [l['class_name'] for l in label]\n", + " samples.append(sample)\n", + " labels.append(lb)" ] }, { @@ -439,76 +304,45 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "e2bb8735-ce6c-482b-9675-302f6848b0ea", "metadata": {}, "outputs": [], "source": [ - "\n", - "import os\n", - "d_path = './runs/detect/'\n", - "all_subdirs = [d_path + d for d in os.listdir(d_path) if os.path.isdir(d_path + d)]\n", - "latest_subdir = max(all_subdirs, key=os.path.getmtime)\n", - "model_path = f'{latest_subdir}/weights/best.pt'\n", + "model_path = 'YOUR_PROJECT_NAME/YOUR_EXPERIMENT_NAME/weights/best.pt' #Double check this is correct path, printed after training.\n", "model = YOLO(model_path)" ] }, { "cell_type": "code", - "execution_count": 26, - "id": "1c6f2681-b25e-4969-832c-aeb8f80b0f21", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "id": "ec6d1966-31a8-4ab8-9ce9-8557d5e3c956", + "metadata": {}, + "outputs": [], "source": [ - "# View data before inference\n", - "sample, _ = test_dataset[0]\n", - "img = Image.fromarray(sample)\n", - "img" + "# Inference will be saved to path printed after predict. \n", + "results = model.predict(samples, save=True, imgsz=512, conf=0.5)" ] }, { "cell_type": "code", - "execution_count": 27, - "id": "ec6d1966-31a8-4ab8-9ce9-8557d5e3c956", + "execution_count": null, + "id": "107d38d4-36af-4d0b-8bd9-926228b3e4ee", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "0: 512x512 (no detections), 6.3ms\n", - "Speed: 1.4ms preprocess, 6.3ms inference, 0.7ms postprocess per image at shape (1, 3, 512, 512)\n", - "Results saved to \u001b[1mruns/detect/predict\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ - "# Inference will be saved to path printed after predict. Change \"show\" to \"True\" to print results after inference. \n", - "# Warning: possible cv2 dependency issues for \"show=True\" \n", - "\n", - "results = model.predict(img, save=True, imgsz=512, conf=0.5, show=False)" + "# Process results list\n", + "for y, result in enumerate(results):\n", + " boxes = result.boxes # Boxes object for bounding box outputs\n", + " probs = result.probs # Probs object for classification outputs\n", + " print(f'Actual Labels -> {labels[y]}')\n", + " result.show() # display to screen" ] }, { "cell_type": "code", "execution_count": null, - "id": "98eaa9ef", + "id": "44098096-2939-47d1-852e-eec74c0cae0c", "metadata": {}, "outputs": [], "source": [] diff --git a/examples/07_example_classify_yolo.ipynb b/examples/07_example_classify_yolo.ipynb index 3f59fd4..22b4162 100644 --- a/examples/07_example_classify_yolo.ipynb +++ b/examples/07_example_classify_yolo.ipynb @@ -30,13 +30,26 @@ "metadata": {}, "outputs": [], "source": [ + "# Packages for Training\n", "from torchsig.utils.yolo_classify import *\n", - "from torchsig.datasets.wideband_sig53 import WidebandSig53\n", - "from torchsig.transforms.transforms import Spectrogram, SpectrogramImage, Normalize, Compose, Identity\n", - "from torchsig.utils.classify_transforms import real_imag_vstacked_cwt_image\n", + "from torchsig.utils.classify_transforms import real_imag_vstacked_cwt_image, complex_iq_to_heatmap\n", "import yaml\n", - "from PIL import Image\n", - "from ultralytics import YOLO" + "from PIL import Image" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "810529c8-adf4-40d1-b735-455a72df2902", + "metadata": {}, + "outputs": [], + "source": [ + "# Packages for testing/inference\n", + "from torchsig.datasets.modulations import ModulationsDataset\n", + "from torchsig.transforms.target_transforms import DescToFamilyName\n", + "from torchsig.transforms.transforms import Spectrogram, SpectrogramImage, Normalize, Compose, Identity\n", + "from ultralytics import YOLO\n", + "from PIL import Image" ] }, { @@ -56,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "1ddb6903-a7ec-4f3e-8555-8132cbfbc4fd", "metadata": {}, "outputs": [], @@ -99,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "f134e461-456a-4be7-9c91-ce26c5c4f850", "metadata": {}, "outputs": [ @@ -107,8 +120,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Ultralytics YOLOv8.2.82 🚀 Python-3.10.12 torch-2.4.0+cu121 CUDA:0 (NVIDIA A100-SXM4-80GB, 81038MiB)\n", - "\u001b[34m\u001b[1mengine/trainer: \u001b[0mtask=classify, mode=train, model=yolov8n-cls.pt, data=classify.yaml, epochs=1, time=None, patience=100, batch=32, imgsz=64, save=True, save_period=-1, cache=False, device=0, workers=8, project=SNOWY_CLASSIFY_SPEC, name=heatmap, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, opset=None, workspace=4, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=SNOWY_CLASSIFY_SPEC/heatmap\n" + "Ultralytics YOLOv8.2.77 🚀 Python-3.10.12 torch-2.4.0+cu121 CUDA:1 (NVIDIA A100-SXM4-80GB, 81038MiB)\n", + "\u001b[34m\u001b[1mengine/trainer: \u001b[0mtask=classify, mode=train, model=yolov8n-cls.pt, data=classify.yaml, epochs=1, time=None, patience=100, batch=32, imgsz=64, save=True, save_period=-1, cache=False, device=1, workers=32, project=YOUR_PROJECT_NAME, name=YOUR_CLASSIFY_EXPERIMENT, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, opset=None, workspace=4, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=YOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT\n" ] } ], @@ -126,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "51d670a0-54e3-4a37-9649-740412e302ef", "metadata": {}, "outputs": [ @@ -134,20 +147,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Downloading https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n-cls.pt to 'yolov8n-cls.pt'...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5.31M/5.31M [00:00<00:00, 49.4MB/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "\u001b[34m\u001b[1mTensorBoard: \u001b[0mStart with 'tensorboard --logdir YOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT', view at http://localhost:6006/\n", "Overriding model.yaml nc=1000 with nc=53\n", "\n", " from n params module arguments \n", @@ -172,7 +172,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py:268: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n", + "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py:271: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n", " self.scaler = torch.cuda.amp.GradScaler(enabled=self.amp)\n" ] }, @@ -183,9 +183,10 @@ "args -> classify.yaml\n", "\u001b[34m\u001b[1moptimizer:\u001b[0m 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... \n", "\u001b[34m\u001b[1moptimizer:\u001b[0m AdamW(lr=0.000714, momentum=0.9) with parameter groups 26 weight(decay=0.0), 27 weight(decay=0.0005), 27 bias(decay=0.0)\n", + "\u001b[34m\u001b[1mTensorBoard: \u001b[0mmodel graph visualization added ✅\n", "Image sizes 64 train, 64 val\n", - "Using 8 dataloader workers\n", - "Logging results to \u001b[1mSNOWY_CLASSIFY_SPEC/heatmap\u001b[0m\n", + "Using 32 dataloader workers\n", + "Logging results to \u001b[1mYOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT\u001b[0m\n", "Starting training for 1 epochs...\n", "\n", " Epoch GPU_mem loss Instances Size\n" @@ -195,22 +196,23 @@ "name": "stderr", "output_type": "stream", "text": [ - " 1/1 0.189G 1.385 8 64: 100%|██████████| 1657/1657 [02:58<00:00, 9.29it/s]\n", - " classes top1_acc top5_acc: 100%|██████████| 829/829 [02:51<00:00, 4.83it/s]\n" + " 1/1 0.201G 4.182 18 64: 100%|██████████| 17/17 [00:01<00:00, 16.26it/s]\n", + " classes top1_acc top5_acc: 100%|██████████| 9/9 [00:00<00:00, 10.47it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - " all 0.671 0.999\n", + " all 0.0377 0.119\n", "\n", - "1 epochs completed in 0.098 hours.\n", - "Optimizer stripped from SNOWY_CLASSIFY_SPEC/heatmap/weights/last.pt, 3.1MB\n", - "Optimizer stripped from SNOWY_CLASSIFY_SPEC/heatmap/weights/best.pt, 3.1MB\n", + "1 epochs completed in 0.002 hours.\n", + "validator data -> classify.yaml\n", + "Optimizer stripped from YOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT/weights/last.pt, 3.1MB\n", + "Optimizer stripped from YOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT/weights/best.pt, 3.1MB\n", "\n", - "Validating SNOWY_CLASSIFY_SPEC/heatmap/weights/best.pt...\n", - "Ultralytics YOLOv8.2.82 🚀 Python-3.10.12 torch-2.4.0+cu121 CUDA:0 (NVIDIA A100-SXM4-80GB, 81038MiB)\n", + "Validating YOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT/weights/best.pt...\n", + "Ultralytics YOLOv8.2.77 🚀 Python-3.10.12 torch-2.4.0+cu121 CUDA:0 (NVIDIA A100-SXM4-80GB, 81038MiB)\n", "YOLOv8n-cls summary (fused): 73 layers, 1,502,773 parameters, 0 gradients, 3.3 GFLOPs\n" ] }, @@ -218,17 +220,17 @@ "name": "stderr", "output_type": "stream", "text": [ - " classes top1_acc top5_acc: 100%|██████████| 829/829 [02:53<00:00, 4.78it/s]\n" + " classes top1_acc top5_acc: 100%|██████████| 9/9 [00:00<00:00, 150.06it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - " all 0.671 0.999\n", - "Speed: 0.0ms preprocess, 0.0ms inference, 0.0ms loss, 0.0ms postprocess per image\n", - "Results saved to \u001b[1mSNOWY_CLASSIFY_SPEC/heatmap\u001b[0m\n", - "Results saved to \u001b[1mSNOWY_CLASSIFY_SPEC/heatmap\u001b[0m\n" + " all 0.0245 0.0943\n", + "Speed: 0.0ms preprocess, 0.1ms inference, 0.0ms loss, 0.0ms postprocess per image\n", + "Results saved to \u001b[1mYOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT\u001b[0m\n", + "Results saved to \u001b[1mYOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT\u001b[0m\n" ] } ], @@ -236,6 +238,72 @@ "trainer.train()" ] }, + { + "cell_type": "markdown", + "id": "454e71d2-fc9c-4f60-9545-bb0997fb5334", + "metadata": {}, + "source": [ + "### Instantiate Test Dataset\n", + "\n", + "Uses Torchsig's `ModulationsDataset` to generate a narrowband classification dataset. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ce307e25-99cb-4c72-9910-3d18d89d9c5c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset length: 530\n", + "Data shape: (64, 64, 3)\n" + ] + } + ], + "source": [ + "# Determine whether to map descriptions to family names\n", + "if config['family']:\n", + " target_transform = CP([DescToFamilyName()])\n", + "else:\n", + " target_transform = None\n", + "\n", + "transform = Compose([\n", + " Spectrogram(nperseg=overrides['imgsz'], noverlap=0, nfft=overrides['imgsz'], mode='psd'),\n", + " Normalize(norm=np.inf, flatten=True),\n", + " SpectrogramImage(), \n", + " ])\n", + "\n", + "class_list = [item[1] for item in config['names'].items()]\n", + "\n", + "dataset = ModulationsDataset(\n", + " classes=class_list,\n", + " use_class_idx=False,\n", + " level=config['level'],\n", + " num_iq_samples=overrides['imgsz']**2,\n", + " num_samples=int(config['nc'] * 10),\n", + " include_snr=config['include_snr'],\n", + " transform=transform,\n", + " target_transform=target_transform\n", + ")\n", + "\n", + "# Retrieve a sample and print out information\n", + "idx = np.random.randint(len(dataset))\n", + "data, label = dataset[idx]\n", + "print(\"Dataset length: {}\".format(len(dataset)))\n", + "print(\"Data shape: {}\".format(data.shape))\n", + "\n", + "samples = []\n", + "labels = []\n", + "for i in range(10):\n", + " idx = np.random.randint(len(dataset))\n", + " sample, label = dataset[idx]\n", + " samples.append(sample)\n", + " labels.append(label)" + ] + }, { "cell_type": "markdown", "id": "caab72b6-df31-4a08-88c7-b37400aec5d2", @@ -247,23 +315,18 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "5644b3e9-a7c8-4865-8d16-f47b54cf7606", "metadata": {}, "outputs": [], "source": [ - "import os\n", - "d_path = './runs/detect/'\n", - "all_subdirs = [d_path + d for d in os.listdir(d_path) if os.path.isdir(d_path + d)]\n", - "all_subdirs = [value for value in all_subdirs if value.find('train') > 0]\n", - "latest_subdir = max(all_subdirs, key=os.path.getmtime)\n", - "model_path = f'{latest_subdir}/weights/best.pt'\n", - "model = YOLO(model_path)" + "model_path = 'YOUR_PROJECT_NAME/YOUR_CLASSIFY_EXPERIMENT/weights/best.pt' #replace with your path to 'best.pt'\n", + "model = YOLO(model_path) #The model will remember the configuration from training" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 21, "id": "295ffbe6-4f05-4c01-bb49-1652869b1333", "metadata": {}, "outputs": [ @@ -272,37 +335,250 @@ "output_type": "stream", "text": [ "\n", - "0: 512x512 (no detections), 5.4ms\n", - "Speed: 0.7ms preprocess, 5.4ms inference, 0.5ms postprocess per image at shape (1, 3, 512, 512)\n" + "0: 64x64 16pam 0.03, 4msk 0.03, ofdm-300 0.03, 8psk 0.03, 4pam 0.03, 0.4ms\n", + "1: 64x64 32psk 0.03, 1024qam 0.03, 4msk 0.03, 64qam 0.03, 8psk 0.03, 0.4ms\n", + "2: 64x64 ofdm-300 0.04, ofdm-1024 0.03, 8psk 0.03, 2fsk 0.03, ofdm-180 0.03, 0.4ms\n", + "3: 64x64 64qam 0.03, 32psk 0.03, 128qam_cross 0.03, ofdm-900 0.03, 8gmsk 0.03, 0.4ms\n", + "4: 64x64 ofdm-300 0.06, 16gfsk 0.05, 8fsk 0.03, 4msk 0.03, 16pam 0.03, 0.4ms\n", + "5: 64x64 32psk 0.03, 64qam 0.03, 16fsk 0.02, 8gmsk 0.02, 16psk 0.02, 0.4ms\n", + "6: 64x64 ofdm-300 0.04, 16psk 0.03, 4msk 0.03, 32qam 0.03, 16pam 0.03, 0.4ms\n", + "7: 64x64 32psk 0.03, 16fsk 0.03, 32qam_cross 0.03, 64qam 0.03, ofdm-300 0.03, 0.4ms\n", + "8: 64x64 16pam 0.04, 4msk 0.03, 16psk 0.03, 16ask 0.03, ofdm-300 0.03, 0.4ms\n", + "9: 64x64 64qam 0.03, 32psk 0.03, 8gmsk 0.02, 32qam_cross 0.02, 1024qam 0.02, 0.4ms\n", + "Speed: 0.5ms preprocess, 0.4ms inference, 0.0ms postprocess per image at shape (1, 3, 64, 64)\n" ] } ], "source": [ - "test_path = './datasets/wideband_sig53'\n", - "\n", - "transform = Compose([\n", - " Spectrogram(nperseg=512, noverlap=0, nfft=512, mode='psd'),\n", - " Normalize(norm=np.inf, flatten=True),\n", - " SpectrogramImage(), \n", - " ])\n", - "target_transform = Compose([\n", - " ])\n", - " \n", - "test_dataset = WidebandSig53(\n", - " root=test_path, \n", - " train=True, \n", - " impaired=True,\n", - " transform=transform,\n", - " target_transform=target_transform\n", - " )\n", - "\n", - "# View data before inference\n", - "sample, _ = test_dataset[1]\n", - "img = Image.fromarray(sample)\n", - "\n", + "results = model.predict(samples)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "135974bd-c0b2-478f-895b-96d487b9d33e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> ofdm-600\n", + "Top 1 Prediction -> 16pam, 0.03368053212761879\n", + "Top 5 Prediction -> 16pam,4msk,ofdm-300,8psk,4pam, [0.033680532, 0.030430196, 0.029595297, 0.029319366, 0.027798675]\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCABAAEADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDMtoMwowaOS4VSpL/KV9/bjP1xUkc4kmn8pV2xkJuYEbjtyAPwwc+/tXb6X4c0q80OzvRApZlLMFJBP1PYDPP1q7ceFtMlht5oLfaU5ZGYqX+XjI9cA8UAectKFliQxhnljLY3fK/Kjk+uSPzNOR5MwLIUVIEw4CY3OdvI68DJ9frXo8fhDRYoQ32QmTaRu+6chiAfxJzQfCWky3AQw4kUnJBxj1x69Fz9BQB5yqK8McYLxksAdzHJ7sM/TP5ipZYhGLgRBemVJPC4Gc/TPNejL4V0Fs2xhLyLCHB3Ett9M9TkD8amXwzo4ZYvJIZmADHPPJGCfoKAPJON3nSMcyt86t0wU4/kRU0j+bJIOqJ8owPu9C317jj0r1BvCmii0ctEdwztdslgvJ/Hnt3qGPwnpK39uwtEECfK6Efe3KMde3LD24oAueGNn9jWRZtxSHyidv4k5H+7z9B61qI4lZE2LvHyOWIG4qOox7kjnHQ1j+F18zRNNBuYvMEMUgUAjkZHTPQ471sFGjsQwYB1YMZMZx3I57YOM/yoAYguDaxrs2MUMZdhlY8cZOTkknP+eTFDHHDcvKY3UiQIAd20KT1A7f59KfP5iSxQsA2AQxYDoVHyjuc7fzxSW8Si3n86cs02dj5zjLHofxFAE5AhitrmMqyuBwvzZ+UADPcYz+eagVozCzIjzNEyggHB3Zxx0GdoH61JJ5Qsg/3I4jiFdpO04C9B2/xpissEJnMqhlBwABwQOpJ/iwxFACCUSLlYMkkqgPOOp/kTTpIVVYY52bbKSG+UHGV4A9sjPOf5UW/ktaFfKIXem0noqrtGP8+tSykyGPawKMrIynHTGSemc9BQBkaDHDNo9mzmEPHEpCA5xnjH6cGtWRYcPCwIZwU2l+QM5zx7kjPt7V499sZZliW4lTCsSFYqoJPfnt6e9D6jdy6iu26nGRzudjjBBIx6H56APXhJG7plU8kE/K4wcjPGc+4/KlKQPA7qqpEzZY8EHk5/GvH/ALZfNcP5lzKzqCNiu2BuIAPX/wCuBT21S6+yoBJcvCwK5D7QT3P555P86APXHSB44bdipG0Mr5xu5GT7fxfhTWS0DqkIjM21RExXcSxPU8/dyAevavKpJ52dT9qnBVzGj7+hJ/kMnA9qpnUZbeaPyb2ZG81VLtIVAUAYAA45IB7dT64oA9g8u2dmWcqdhYsgI2rhsjP4nFTSxwSy5jMapGPOaQ9HAwST+n5V40mp3bzyBJpxISwmCyEjg8kn8AQOvPtViS/uQPIS6nVCduFk6DHPfpyKAKbQRTyPJdKpcS5Kjp0OM9j2/SkSJIXJgWQFxlt2WC54HJ6Dk8D2pJAfNAib5ztaQ5IBycHAPT5u1Oy08Jj/AHo8wKCQ2OCDhfY4IyRQBajwVjmVC0nyqQvAHTP+TVG3CXCNG0cqiF9rBumAx798gg/jjqMVPvePMh+Y8ho2Pbcf/r/SgKifLEVEeBgHONx5x+poAasLC9dNzNGMSR7wOpJYgfgFFLdWyy+XuwkZkIZeBuJGQc+3FKyJGkcindJD8meuPm29fwP4E06BCht44/3uEAUyDAJ2kZz26UAVLp/3kjpuJUHlABuCnDDn8D+HfpTpIpIv9HUr9/5IyNoXk4I9fTHpRLF5cmFUFd5OCxOSQT17fNjH1qWW522avGA8xcMFYfiFH0BFAH//2Q==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAWeElEQVR4AT3aRc8XSxMFcBge7ou7u7u7Q0KwAHsIISRs2PIxWPMBSGDHAgIJENzd3d3dXd9fcxImuZOe7qpTp05V98z/4dZetmxZ3bp1//z58+3bt1u3bhmPHz/+8+fPX79+bdas2atXr2rVqvX79+/27dsbm2nUqNGNGzdM/u/v1bhx4w8fPrx58+bnz58tWrRo2rQpA48vX76sU6dO69atjauqql+/PkBL7969a9KkCReY79+/b9my5cePH4E0b9784sWLvXv3rl27Ng67d+/u2LFjly5d4Fh98OCBx0S0ev36dYANGzZ8/fp1BbFevXq/fv16/vz5yJEjR4wYIZ4E/vvvPw41NTWfPn3q3Lmz9LBB4v79+23atLEkB+SSvBhmOnToANQ8F+zbtm0bm2PHjjHDGIgZ7IHAR9pYzi6B4P/48UMCYPnK89KlSw0aNEAPXeogKQoOjGkhc7DV1atXZQmre/fu0FERCYoA4kmmT58+379/Z83NI2bgBGjVqpXwNFAW1NknbQFevHhBDuhc8Jg3bx5kVIJw4cKFQYMGcScwrkiDFVQ17t69a6DUN2/e5MIXJgPyq7AxWBEhC4oevaoePXqcO3dOQhhYNvv27VvWjPD26H779m2FoissMjAwYA+XgfaTyYYNG7SEGE+fPj18+LCiQUOCFnJG0YB+vNAiU+YJYVXOMZAh9gz0AlGE9uguBHuVB6h/cONlsiCjPnr0aLRg8Uf02rVrqDACKsUjR47AUmXOhHny5IkBM21ALfV9+PDh6dOnZ8yYocqKKTfhoTFzCfPlyxcDIWAKh24cRTHPHjk2d+7coa78JckGOeJSmihkMoMebqoHR0fwVdVKukwZcWvXrh2RxowZ06tXL/FSDWH0DKKwunXrhqWLserfu3dPraxqM2XBQymg640o6q6dbEFL2kNI+YwaNUoCgsLXNtkAjx8/Vs+hQ4eagSm6C5QyosQd49irnljQ0FCc6tmzZ9ZYm+VgGVcO+Fles2bNxIkT8SCAGQUhoVXJYHn+/Hmb59GjRx4HDBjAgIpB0G9iSF7dwYrihMHbvsQYMjagyB9waB6lF8bCYeVRMsAhS0zZrZo3Q2s4V65cqTSrQlizE7gpYorORyZ9+/ZlnRiCgUPFEhtFAIGiwCgm7f79+yu0NmCsLCyBd+rUCTJjMoMiFi96GauY0HFXH+c4XUmuT3QmFbgTRTihDbA1Zm9J5fV2BculoHDB4aedSKW1JD1w4ECPGlQwAaA47A4dOsTszJkzPXv2NENyqsiciz3n8cSJEym65BkgZEsgevbsWWedKDIUTlBsJIyKSTnTS8U8mnSpoRAA6W2bEQIUX3zYQ8Ct9vLly9Fll7S0LG28tnSLAPTAzFErEurmgeY0MC9DnUBduHqJEOqgPcQWhkjobt26df78+fKxRE74dj9w4bibNKBOofL30hWCOmSxUjTSqFuiG3Tt2hU+EOyHDRvGt4Y2HOx31nYbUI8uGkd+raJJ7Fc7jMZY2uU8GRNMYOwdPlkydlAMHz7ceYWcTAYPHuzOHggoVOwZj9TBOwm4axiPEnNOyNCWoAjtldSJYlXz2I30ElElufTr1w/bGqlIl6c7paWoXmoEQhppdKu+L1RA4RBKlUGYgSgSEIIx42JSGrTHmFoSUwrzOgQaG/nwJbfSGXBMICXN7tQqWKYLQAHnwtExZZMg5lWIp/RwrrIj2em8cePGmSISOwWRvaguW9Oq9FCRtxnOpFJKLU45hWbABV2XSTMGFBIYS0uSgSyQeb0EQQ7uxMIv1CVvibEScWSsn62KRQ6ZRK/E4l6i+8/Fx3L2nDeX9nJgsQYkgDD0MJk8bV+g2NiXOsGrzXyicpEne48SwwYsKu45VcQSnjRWjVMHOC6BWCoLQDbODGgQXCyNRWTAbNq0aTqZL/Wry5cvMyWquyKytqG1ilNVVD64WuKJE6LpB3fblCqqjxnlGCBhMxhYcsCJChYUM5GMNYalJOBRGpAZkNmeiSiYUQ0NIWwzWkj1wIEDCsjRRw1LPayFGJipjLxcQPDxQYuKTSOTqVOnKojALp1AdRlHVy5icNa+kuQoT5dWQcgWcmBjb+yyZbU+kHyGENIjG8mARUuqAmEvE+oqqSig1IGBJKE5P7KjNLlewBa+BICUbyEvUSSQdk4Bsma76FRaYuncRN3GInCqQTz2kQSKJfmcOnUKAwZS4mV7UE6GxnLj4gzxMmaAohmxUCEZAiZR1zwuqwLxtYvk79PNtjSG4GAUSE1QUnngvhorWIh6po1zU3g8HCySY00D6eWAT6SjR49SiIoiSUMMAahlh+gfPFatWgVTswmAB04GJECXvR9DkKnu+BYoXaoFnOMwNRhA9tRB1MBJLS6NrEKTGwNHKgOPeqGSouSEdPKgQv70CQnNCyk2oFRZPpIUOw2KpVojJJngslyyZAmlQZm0qiHlQAs4GPtG8KqytG/fPi5OWy52nbamoygujKnpjhUcBipgrFBbtmyBiT1NKVJayAmFqK4aMmQI0hYAcTAQQJZS14hmjLWyQwa6jwWOOCF3/Phx73nkPGpu8QAaex8ROLI5vIWntEzACjd9+nQ4SAikzShiHntm8TJvDI0xxu7MFi1aBJBlviPVp1IpybE2yKeSZaa6CHUlUwQ+DivtgZnq6yJ1sN3lI7A6zp07l3taiLE07F0z7PVr9hI08ZD2yEsRsr+FMDbvhCGTJdsDskm8CeQs0hSqTe+URVY6lhaFG1wJoEtC0AoExd0mBr1y5UpAONkJCFEIqA0TVWSiIAzMu7s80o8NY5yA0EJ7QMBAPCTo6sAQhQQRDiEU7VHHpTMHDrG0q44waRU3k+jJRzsgxgCUhi+fH1DkrQ3kdPDgQZFsJrG9yxYvXqwZ0hJSZUzvJMxm5syZzjVckfY2cHaJCkoYLs4lYVB3mXGnn/JKMi7C+72fHwAs1cclivzTaahD1ts4cOFuQAV7zGFgL6l5+SKXgAD+HiEz32F8QNPJMiCm0E2SzYBU0pDevy8iSqiyg0LdpCcMCRCdM2eOJjl58iRYNmZkJXl5IoGo7hIFlChBtsTAiSQWezskmetJlcyWAEIj0YEIVGk47YGTGIxUFi4ePPkTA2MDhTPgrHnAmUd03bp1AuONKBISNmbAGD+XSC5eGoB4xl7woohFXceAbkSLOl6U2MN0KqJlXg4cscTQeSAiWVkKhJtaaXvzpYW4gYMujLqoiRjpcjPsNKvewNU8sxQNOo1RYeMcZO8jSinEiDyEYOz95c5YVDlQFw8ktBxdXNBcNiUcIWwnCQCRAwl8R8JxcEvApkrpuBsgI/nKLHRVhouNb31ugEyyo7reTaFXr14tkkdL8nT3SAPUTdLJAQVHQ0IQIEen5J3lviMwACg35HBlYIajxCSjdLavy9eu6GaE5ktflw2ALqqY+L2xf/9+9UFY+1Xbt2/Hg8zEUwe7ngb4QcRJJFkJKZJ3EK6pAx7kBGGeCzOkReKlEyzhatUMObV1Dhxc6Qrf/jZwNHuFe5cBYQmBFwTh0DUJFiU47hJ2yQHVKVOmpBF41XihMAUKUS+RDQTS9q4/7wB12nBjSmCPCAVd2sTQEnCNecnEJ6BdJDB1udgt9qJ3vFU8iMpd6ew6j3kVMjOPuvTQ4C5/jsSSibFJCUiVaibxZGm/iaK1CnUjuI4RdigmDCFFBSclJLxZJEBLFVBQAmDvxWdTQkmP6WM40IThgiJaNjRdQMnTgDt1rNr3qAhHDkRxguO3ImZcgBCFjbebPmFvE8ocjhCi45CNUb4OJIcZ9ujm5QpUbLi6SD6qZmzGKslVTDzKydlf9RDFieSiwhFD0ShneygdWJzwxsMjyx07dnhD0cUjlgjpeO7MANJCVopp58hEOIAs/SgHLgdR2GBFEaErakkOofXr10tAJIGZugSjGWcXOLtTGsRg7PSAQgmvISJh4/izigfqQjK2oZO2zAkmdirjL3NA8PYtzUaGzGxKsHYFThDU1mQ+bWxOxJBkTEEhPBLR3biyIBvQs2bNkjf2lLABJEpIvHPOwBWDNpRgIJiy4JSNpVDE0+uSkbZJQoCFQ0WEoFFdVL/HycFdLDWBoG38oQm+cBMmTODFgD1pQNFFl+olCeeRI0BQvjtIUwnMmUPakT91Ca8C3CjnVUokphj7nNQ5efl7tE88kh9jO4xgEqYuKPb4mWQAX01UDI7tS1GqoU5CHwVsFi5cCM2Ai+1rySNNCWzsZDeJNC/nj9ZXXksOXPYVU8WSn2UxgoK3lLxEiOETg51dYVXHW5IeivrHKqUdA/Y3ouaNmfGVBu0lpiY08giZKKAYp6n8UJSYMXvtIXkaYyJhJfKYFrDXXUgK7bKU96bW4FveSrKxj90pqj0EJpVI2HiUoeytCgM0hUJlz549Xk/SsArdjCU20uBudxq4uKuqR0VPB6twcEjGS2ead6Qy87dk6rKki9wyib3otCAiIRgzkCQhSlvu3LlTeDVSWdn79APEATQUpjzddbO73AhAY0C+ETCGohPkT0JLLmYSIJVVvjm17E5aUEQIIPJECwnJi6I4Zgz8EdKJxFcpIOeExccjKMYYU11EyZOGQTV27FjO9FZopOWdRL3VBbAvEVKltDIfG0AMskFhAD17TgLSZuwtC0EYdzYAGeh1ReBl3kUCd1tfqqK7q6Rfdkj7CcoFDlltA98ERFFJ3ExSwTxAn5v2nvnynWOKolQExIcS6NoiJFRENRWbTWRAGiKu2cHG/5oeiNg+yJEDzQZFekuD3lbNwCeeQGDp4kKLjehsCJQ+hGmGIzSrLo6MERORLzMCwa9By5rGUuV0Gzs8QOBq4Nenu6hEohZPqoMwwxKErkAIOQYQ2EhYuW1BIO6i0kyJALKXGxKOOAhmlJRkZjSYu7FCYRVdoDkGKKLsimNSg5lkIKif5uUfHvV3yu3QpVP6jPb4mZeYSMRAUR30IhsxPAIVD6Hs43DllXJbFUZ6csbAYc/Sqg87IB690Vh6sSimHqYjJnJAw4ZEgHC+pVMrXy7Q7H6EKSU6X0u1V6xYkfPIKe43LkKOaqb+fcWbwk7Nvzmzln32CYE9smTg6w2owBjoSzZWuaedvKT85vT16/zmgpbLflBDijjRN27c6OUlGT8tZOJ8lIAB4RRH6Yjtgil58sGHTBEtYx5IyYYems8yXZ360K0BcurbkfaKBiChdNlIXUeiiBAqRDJG3WM2NyFhmjfDl+RCAgTiJepQQmXXrl1+gukBfaXr/LbWqDYoX/i0V1KsvDcVkI27C4JYEsOQJXshyomLq8wUy5sLqEfxcmI44JBGyOHtXJKDjoRuh7lMAmVsSU+rjwDQxTbPUVnE8E8KogqpVQBC83JVWwmTX0tQFIjLErp8ac/RoWSGbxhmi6uGbaMPoZGmHPMuJaOZgagu+SQTnlLHD6hXBANhsGQsW3VUGTZEJS0XiNHGfhBJidljw1JijMMSFSEENYkiLf01RLZwCEF4KfG198gkNDNB4dMOiNxcHslRjltXGoMpByRguRPDEtLs7BMDuF55mdEb0jBDSCcDIRWHi9LhhJwmceYIyZI7xtjjigovyIyFkzAJ/K6CxtivdX/gwQQ/3WEAXNPCl5IZCSDgL5OisC9ncLgKrItYSy57XFT+tNSm2VIiMSCMgY1rlTaMEaKct54lLxD22l2JVFlgUSkimMCMlVQIbCRmIK4c5APTKnz/nOVRAbdt22Z3wZSMEEDkTAUuzgYDrCoxLGuSMONJIY+gia3WMhRSeAoJyYeWQvLnAlcAzJziZrSmO/n90tU5TmS0UDHmLhCKUoIDlotNhZZ5CasYWAaW9u7d64yaPHmyEMKxQTrJe2RctP/7zVIjtrJCpCUgzk4xJ6OyMMUPG+Ejm6pRjiVEqyqAosZlJnOE4Ggkq6gYs9f9lsQD6BeMc0lh5SxVNsSikbjpciwN8vc5Y83pcBeR8I4pJRULH3+Z9QqzxalT/tIrB+eJATjntJ+2diRcHydOaPPYUwIP/WeAjbrhp23IYFImuhk0kTQMS+EFJgRfAuVCmjGKvFBh6UvMWImE9uaRkkJhRmP4ZjSwKDjoGTOaEywCoGBCq4QkklIqWboWtBgSsLFmz56NhABOLnIy1kIMYMnEq1QdkkAaSTDVsIS3GSAeiSKkrSkxdPla1WlWaSd5VOKYFxkDxYQMQS8xViJdoDsw8QNLDSXABp9Kipb50ICEpBUSRSGlJKQjiJyspQ7Cex6ifKCzlzwU6IGDy5cBCdwZeFRSnYBiDgPzeNhj4iqCO8lprPFgJhmADOTmTU9clMiXs0Ha2NKRBGiUUwgzLAFllip8tB1m2ZFI4Ke4Agiv84xl6EIUguTVAUWW0LAR0p2KLm9WQuhS8hvABysElgbQJAAnBHSBAqILnHAiOg8YRxfvSmjufk5hWFoor08+KTfSPK2hBVp45ET1d3ADZspCGMbuuNIyHUjLzZs3k4SvGdp7CeDkjrEd4mSjnJC4GsDEUpRUEqBwVpOS/CHzRWDTpk05yi1JyQyGqspFwcv/T2jL2jQCiwfawULm6MTUn3F4+isdOAGEtNXEFkNIYXzlKqClpUuXrl27VqEJxj3//oWoS3v412k5K4IojGlBVDWHk5l0HRoCuWNFMoIuWLAAK46MBdJj8hFaF4AtpxA4EKYoSg/L+k8OLrHzRwHW+pjMNgkeNObC2LsiihJGsEmTJmkM8zAlTxfz7EmALjQhQEGWOTNjzIxJa2uSBg0XTC7OXAhgHSQkk5JsZQUQQ2REKXow0uKAKCdetGHqymYSmzUUnWAsbw3tiyUbUQAIjhp7gOoCA0FFGAEwpp86myGNvwNIQyxvG0T5ukiLH7rmYbrISiPpuRw7lvQFWDT0sEccZGKmfAmK4TXh7lI7s5zDQDzfFzgRCSFvBm4mqSsTS4wF0446R9u4aMmSO9IICc8YJ0uiZkcinQ8nYmkJlj4ZiAgTByGcufobXVA+2g2USzhpCMQelKCQS05+wUCkEyq+Z3J6Eg+0tlEWCaBFct/AaWgxrGonjlji4Y6iRyBs9IDY1PGqElUlta9f6M6MHFZRV1DSSM8jBL4s/SYRETmVkQ8XsSjlxZw3jyXG8JGv/LaQCjs+piyAs4CBSYj61Qx/BxwSQgpmnmZ6QGLQ5YM0SwmI6oKmjOb5pg8ZkJ8BM445l626hNNCMnEhR2O+trKm1eFm+OLGUh0SQscyEL0iqgV6Q0nLWuPJQRjOHMAhISU+slUl+SgiljIRQz+IYUb+0iO5u0JbUgT5oIu3S2uJYjM41mhhRqtABkgIP3xNgpKJuHohfzvLBsu/KggBkAsDOOV/qNUkms/5yNM/wygZ6jxJbgYbb19autKIcFFHTninEPYeSeiRjTRwipDSYJAGwIyLR++KIEiGmVUC0Ys0Pni4q7yelBJMZyBwgiJJCwriTWsGyJQEIrDA0AE5XpC2RgMQ+lVBfeIb299i6KKgO3kwhk4YRJVR2gKQhxxWSYWfOzNL1GWTMwNdhyZLWZkRgsZE5RhpMPZ61iF4Y+XYAfUvAWxNYmhLlH+Hgou0ZZlBhOvR68ndKtBojwqb5CZtlla1ky5ysbHJCMyeFi51kxjqTkyPVIcghAqzB87SvicNcj48LUks7eBuTCl6IQokrFjyIqXiaEsE/g/N2ARWvKfvxwAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> 64ask\n", + "Top 1 Prediction -> 32psk, 0.034033387899398804\n", + "Top 5 Prediction -> 32psk,1024qam,4msk,64qam,8psk, [0.034033388, 0.02703341, 0.025372362, 0.025346853, 0.02519393]\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCABAAEADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDRha2UQtwTEAASvJOQc59KztiJ9qSSR7hGm+cMvzjnBwe49PTHfpV59LcyuEt3ngeNH2jkBsMpJ/BV4+tLNZ3JjjeCAEEmRNwK5Ygsi++Dng/0oAiaO3lxKVwfLPm9sg/1IB+lKjSpbed5I43DPUkYyc+nzEfkabJZy2lrFE8TbzmN85csBHyPVicE/hVhINS2xLJahxKoZyh4BO1uM9TnigDNCTXFossW2G4eIyQuq5AQkHbn1+79cZxVgSuENjKv+jShhlTgqoYjGfcAc9cHNO/se7htVMvmyQRKJS7febBYZ2gf3QPu4GSeKsxaZe4nk8sD94WMirtzsIG3HpgFc+2fegCoSLhVAuAroWViThWZjyf8BnofpT3kkYxy2/lAMBhd3Qc/MV/4EePSmw2N40hea3aJNw8uNR03ZOT9f0zipkhvbe3KR2qyNzgJyGZuST+YoA7u306O2sYmlnZ2jKyN5WF3kckEevyn8zUFvYRpLtiaVvNkSTGwgAegU8jgjP1NXvtEMfyxPH5nlkSmQbdnKqCc9iQ2PXtTmljRDL5QUxqzsOCQdpDD8S2PwNAEUlsjTg+TGThQFUYHyBiCfYg/kCKghsbeBHSWYh5YkDMTuVBjJIPpwR+FW0UrHJBI+/YXLP3GRnjHPByMegpZ41c8xxCFZGUgnI8pl5H4Fh+B9+ACOXTYHtoGaeQeWDkMM7jtJxjv0/nUEFlbW/2hWnZw8xjRSOpYnGPbr+VWf7RWFd0kmG8wxxkHqwAwB+T/AJUqy2qJ9oEYilMKgBWwSQMjj0+f9aAIksobaVblhuQqI8v1AGMnJxwCD9Rgio4LGNLhr/Y4QMrhCMnoM7fpx+ZFW0a2EUlsWRghYjK52nLnp6cHpToIxIJ4rhsbzgg9FJGCB+KE0AQrBE8YZlZVSJjuVeCSBz65+VuaFFnN5IiRSGHyYxgjbx+fy4/Cs+01aX7LCkxgJBUT+a2Bs74HcdetRjVHabMjKHWROoGSuSccdvT3AoA10jxbYuFWWVg6naMZXHGfw5x602ZoVaNVR0G5pQmecAEKv0J5/Ks+fVrJViMkpUE87+ozu34/THvimW2qyrBLITAQsURjYcsXAAYkn/Zxj8fwANVLS2t1MkgiCs2S/bOAST9AvBpFeGWY4tkVWRY2dzzvIKlcDjIwO/c+nNC51uaC2h2CLJU5C91A/njP6UR6zIDcLOYvvOyEkdQeP1xQBcAT7E080Tb2EkagAHC7jk9+cAf4U5IfKtLiUxxyDJeMjGSQq4Jz7kmqUGqRPfMs0sbxxKmArZAfaOvvtOR9TUEGqRi9eIBEtw8fAIwy8AZ9uW/ECgDijBGTcxiUqXg8syZzkDHyAd/4jn3pbi58t1i4DOPlw38THAGfyOPcU4KkWVhUh1QrhiRncev1z/Oo54FizFs8uUM0xYsMK5xgdc87j2xx+YA+UMkBUbPKwXbexwrYUgfrj6Yo3xWUskUgkeBwQEYk4YjLAe2SAB7YHAqITb5I4zthVV2YYY2tkDqeoI4+oqUxxzbiZdrwlnkXJwQSM/ljOe1AD5RtcBvnDHAJ+b6rjuMn+dMjlWbh4zy22VjkHIA5Ht0+pqC3SVJYXT54yoYoxyQwLcnnjtkAf/WI3d3MxIaFY0G0JuCuGIxu/LPXGDQBMs2yOaeYbIIlxtVOTggkEdwT09iKdgbstcGRsHycSFQ3XgjvgAn8MinC2d32B42kVhhiv3gP/rYP1qMTSXscBt8IkrfNMy8ZxzgZ6cH9KAP/2Q==", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> ofdm-512\n", + "Top 1 Prediction -> ofdm-300, 0.036741953343153\n", + "Top 5 Prediction -> ofdm-300,ofdm-1024,8psk,2fsk,ofdm-180, [0.036741953, 0.026457129, 0.026435416, 0.025381025, 0.025223134]\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCABAAEADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwC3eSSnEau0YRI1O2MlSSFwuByBuK59BnPFWJA9yiRqVCunmyMTkHK4z7/L/PNSTaVeX0TSQQ7MP5qSYLB2C/KcD7wwvT6HggVINK1K58uCKze3ukJkljDAg7GAKKTjgjbg4xjI4oAhVJlkkgD/ALuQfupXA6ljj8cfyNQyBogQ9xwUwQq8DIGRj+9z+R9q0b3Trq8E728LOAjHymxhn+YIRk8YYnP4VHb2F19o8u7RpXjK7CI8AZHXqcn734Y+pAK0UyXEccpbYzLsaIEKzMT0z2yTVaQKzBhEruXxtQfeVWI4zgDOc/ievWtM6Le29lIVgldVVmLJgsTnJI9CduePenwaFqMufOt0ABLFUJ+ULkcN6Z9hmgCo14PsTHzPNSQP8wUnOCOfqQpx71BPI4kVhAB5ZJhzjDyc7gO4IA+mGPWtGHSdQkkLtAvkOixyJgEH5Wz7Y6mqV6L6ws44ngj85mQMDMQMfKCxyOBnd0zxj8ADtNLikg0izBRnk2h4wgwE64U47Y+X8M1PdrPeQvBG4S6mYxeapAKr1BGfwzwR14NUtOEltoVq1oxSRlZ2ULxlskgD6lefXPrVpoCl+CkYmkJDIjHARx8zbjzwPMGAM4/OgCGxMU1sk88fyeaSdoDKxMh24x2+6c/5EkMMIu1liEUaySFpCFxv+Xr7ttjPP09KkSAy2QQzbIklMy4xlsA5Bz2JGasRHc4CCMK2d3O3kKcHH4YoAq2qSjzYxIzCUeWMZUHAIwOeD3NWZJy04jjjKRRnLqFyZMxsNv0GR09PfmBWjaHy1DoLmeWaQlvuod5yp9chf++qlt5o5E+0qTGHbzSUO7O0hcD6gHI9/WgCVW8priKNk8o8oCORkYGPXnNchrVu02vlh+7lOwuWwfl355HofmI+vtW2s0CIzINqo4aNYkwAWxn+YOfck9awtadm1a+kZGZZYoin8BIIOAO/BIH40AacECT2qCWFJJJYVwG6IcIOB2wRkdeSOa2UVEhVY5d8LEyKyrk8jrn6Y/Cq1hcRLpsTurMxiU+WikMFKg9D/s7vxHrV4A2scKJ5eYVwMH7w6Hgexzn1zQBStx5gjWO1XzGlZN8i8xEY4H+ySDT4o1hVpngVnCKwQjLICeDkdwMjv1HOKWDN0xcyzbTPIAqDZuAcYIJ6nnr0NRWiXEIWe0eElnO8EEqqlRjqenGeOufxABP9naK7zF5bbZlxzkeWRyCOxwT+VJBDuwH53hNwkCgRkkgkYH3uh57Y6c0yK4dpDZxRPbhSAjs2WcHAXnnqd3J9B60x5Ybi+dYImGdxSTJAcjjfx14Ug55G0DGDQApjjgM0bNFHCf3cayjJbKDAHuAGOOcgVg+I7cNrMTeX1TYO4JUEj6cHGRzx7V0UEDOly9yvkkud7BuuxCoJPuO/piuY1R5zqitJM2yJBtBGM/IOvvg9R/8AWoAr2+rajaxW1rGxVVLsZ5AD5gEZwW/HHpnA+lSweKLiMq8whAkO6OOLDZBOT1xg8HH0PpWQ6yvbzRSCRIzGsbAyNuYAHkEHI6gk9fwwaV7VF2SMPMO8wjd1VWUAgeg4bj1APagDXj1iWCK2FxNHm3zKo2nO09CfU4AFJ/b9xNcN5kyJFtfLYII4GCO2BzwQe3pVBFgmETTNGxSUxYJ++QmDyen8f4YNRR25YpNHCiwsOJG4LbQCu7Hbljjtk0AaKa9cWdrO0LxPBDmNF53vIAcg+gwUIx6ccYqdtfmjMUSMX34YKVIGX+XBOOOcZ981l4JbZhjDE+USNdxHy8nHXj5s9c9vSnQkSSNFCGSK3K538s5LE5+mc/iKANFtbvLi2nheUM0pCsYhnYBk8nt0xn2qtdTi81CObOJ4YiYcoMYyOB+S/hUEZWzsXOxQQFjlIG0uxIGOfYYByfSo/OBgjjgkWWJIxLHsXlipJAXtgfKMUAf/2Q==", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> ofdm-900\n", + "Top 1 Prediction -> 64qam, 0.029625799506902695\n", + "Top 5 Prediction -> 64qam,32psk,128qam_cross,ofdm-900,8gmsk, [0.0296258, 0.027955513, 0.027107207, 0.02672575, 0.025072215]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> 4pam\n", + "Top 1 Prediction -> ofdm-300, 0.0609188973903656\n", + "Top 5 Prediction -> ofdm-300,16gfsk,8fsk,4msk,16pam, [0.060918897, 0.04688027, 0.034186676, 0.030456385, 0.029908646]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> 16qam\n", + "Top 1 Prediction -> 32psk, 0.030685605481266975\n", + "Top 5 Prediction -> 32psk,64qam,16fsk,8gmsk,16psk, [0.030685605, 0.026008802, 0.024897756, 0.02345956, 0.023073435]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> ofdm-512\n", + "Top 1 Prediction -> ofdm-300, 0.03914753720164299\n", + "Top 5 Prediction -> ofdm-300,16psk,4msk,32qam,16pam, [0.039147537, 0.028814971, 0.028565336, 0.026398636, 0.026259989]\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCABAAEADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCCMXDW5jCqAVYBSOWIznPrnr+NPt8BmLLiRXOAo6jGSCPXk81K9hIt7JiOeRxvPKMPmIGNueP4sZH/AOoa1uI0ZxbzmVhhAUICHAA+nABz6E0AVgpfzEuFIuDvZGXp8oBHP44/CltxEGMXkDZJICF6hQO5+pz+YqW5hm3TQvbzII1DKfLwAcZ28jnuOO1LHZXiyBo4Zvs4UfeQjccE7cY6jr+VAFe3SSSGVpQY4MgHGRlfTHbkD8zUsI3QMiLjcwwSx54yM9/Qfjg0qQXJYoRceYCQVZDlsvnI7Y2gcDp+NKYLnzWjFvLIHLEtHGThNoGOPf1oAhcJCrTGdlZyGOfurngZ/L27fixlJSBrhU4cSOUbo2AC2eOCDj6e2avpY3kyCExShfLBG5Cvc9T64H8vWopLO4S4S7EBSPOW3IeCfQ+7L09xQB6VAg/s+2KgsSqEdc7iODnsOO/pVmWWCIIvlGRXGzaRngAHGfXbz+BpygCxtrjaSioCUb5cgAHp+AqPa0cR8gARmfJRxyowQwH1/lmgBs0cKtcPMmGWIy+Yw+X5ckfkQPzNWZbWKQLbuABHhgpXOSRtBz7in7lSYvIFYuuxWwRlue3boaijupVQySkCRnyo4yVXkjGe2R36g0ARx/ZwFaSILsRcSA/eJOBj1OR+tSlFjvVeFUEIjO/Axk+nvzj86rRKFiR1ESqG2KVYgLknkL/wEfmavHy3lKhVKogby/cdMf8Ajv50AQKpkkfegix1DgbWwBuOecDGePb8aCkXlvDNG7qAUZSuBkDdj9cZHfiiGWIEOz7jJjypB3XaefQnjr6GiGVXeGOTaxbCzZPG4jI/kKAKkcyraRSud7eRHIWAz8r9fUdQP84qy1r5wPRXJY7WA/eHHyg+4KgfSoLNIl0sxyiNoVTylRTkkYUYOe+Qc+9SSrGpiAO5hKwXacMCFIyeeecfp6UALJAGaNhEquQm5XwCMg5BIzyAScdCQPXNMFqtssFzK7pnahONz5O0YGB06k+n41KwKQzSMyNKpO5gmRkbece5qR2HEsiLtUFWVQSScAkfQHNAEJgjlQRSbAAoGRx2Pf8AFj+NSXNoqxxvvCRGMsGJ6s5Zv0A4/wDrVHa23yQzySqrbCZgq9Wwo457gn8cVYMnm/JcYYbt6jbgEgHIH6n86AKGyKRBOYVjdXzGcZ53Anj056+3tUtvBKkJ2pkSLGVjkAGwZHynHHTI/Gi2ihEK+SQJIokXYoG1R2UDsMEcDjj35stE0FgyxsYzIrlnZvutgfXHft1oA81k1S8HnhZpET7+VAHO0njPpnP4VD/b2tiZZftg8hS247R83Gevbp16c4qivnMHluG8uMlNgc9OnynHHUle/wCtNjVmKRoUcIihg3BIGOuOnBoA1IfEmrRgxxygLN8ynA5BwD+uB7ZFSJreoRymJ7h5mVGfBA34PRV+uO/oKyx9n/1XmbkZim8cEDHGMfT9DRK6tG5dMSKhYMQMo2OOemccfh70Aai6/qJH2V58oxXy9pwVO3ke/btSv4n1BLp3e5c7ZCFCjk9j26Yxz7n0rJzI6s0uxVVgWwMkfNx9Oh5qGNtscm23MkgyhByueVJ9eoJP6cc0Aan9s6isiSJcOWJUNlcAsVbn25556YAps3ivUZreH/SA0FwpLMVDBgcYx9Sw9elVHjhjd3Cgo/zKAMlQuBx6cnNSvbRyxMMZj2febA2kAYA/n+FAH//Z", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> 32psk\n", + "Top 1 Prediction -> 32psk, 0.03091914765536785\n", + "Top 5 Prediction -> 32psk,16fsk,32qam_cross,64qam,ofdm-300, [0.030919148, 0.02701051, 0.026937515, 0.026757663, 0.026381968]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> ofdm-72\n", + "Top 1 Prediction -> 16pam, 0.04030076786875725\n", + "Top 5 Prediction -> 16pam,4msk,16psk,16ask,ofdm-300, [0.040300768, 0.03465414, 0.03413951, 0.032029744, 0.031986356]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Labels -> qpsk\n", + "Top 1 Prediction -> 64qam, 0.027023477479815483\n", + "Top 5 Prediction -> 64qam,32psk,8gmsk,32qam_cross,1024qam, [0.027023477, 0.025516286, 0.023688382, 0.023669185, 0.023428323]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Process results list\n", + "for y, result in enumerate(results):\n", + " probs = result.probs # Probs object for classification outputs\n", + " print(f'Actual Labels -> {labels[y]}')\n", + " print(f'Top 1 Prediction -> {result.names[probs.top1]}, {probs.top1conf}')\n", + " print(f'Top 5 Prediction -> {result.names[probs.top5[0]]},{result.names[probs.top5[1]]},{result.names[probs.top5[2]]},{result.names[probs.top5[3]]},{result.names[probs.top5[4]]}, {list(probs.top5conf.cpu().numpy())}')\n", "\n", - "results = model.predict(img)" + " img = Image.fromarray(result.orig_img)\n", + " img.show()# display to screen\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "134d11a1-7ab0-4bd9-92cb-d0b1c2cc8b6c", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/examples/classify.yaml b/examples/classify.yaml index 578abae..8371522 100644 --- a/examples/classify.yaml +++ b/examples/classify.yaml @@ -1,23 +1,24 @@ -train: './datasets' +train: './datasets/' val: './datasets/' level: 2 include_snr: False nc: 53 +num_samples: 530 # Determines if you are classify all 53 classes or modulation family (see Classes below) family: False overrides: model: yolov8n-cls.pt - project: SNOWY_CLASSIFY_SPEC - name: heatmap + project: YOUR_PROJECT_NAME + name: YOUR_CLASSIFY_EXPERIMENT epochs: 1 data: classify.yaml - device: 0 + device: 1 imgsz: 64 batch: 32 - workers: 8 + workers: 32 cos_lr: False exist_ok: False @@ -78,7 +79,7 @@ names: 51: ofdm-1200 52: ofdm-2048 -family: +families: 0: ask 1: fsk 2: ofdm diff --git a/examples/wbdata.yaml b/examples/wbdata.yaml index e5283b2..3392ec1 100644 --- a/examples/wbdata.yaml +++ b/examples/wbdata.yaml @@ -1,72 +1,29 @@ -# YOLOv5 🚀 by Ultralytics, GPL-3.0 license -# COCO128 dataset https://www.kaggle.com/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics -# Example usage: python train.py --data coco128.yaml -# parent -# ├── yolov5 -# └── datasets -# └── coco128 ← downloads here (7 MB) +overrides: + model: 'yolov8n.pt' + project: YOUR_PROJECT_NAME + name: YOUR_EXPERIMENT_NAME + epochs: 10 + imgsz: 512 + data: 'wbdata.yaml' + device: 0 + single_cls: False + batch: 32 + workers: 32 + cos_lr: False + exist_ok: False -# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..] -train: './wideband_sig53/' # train images (relative to 'path') 128 images -val: './wideband_sig53/' # val images (relative to 'path') 128 images -test: # test images (optional) +train: './wideband_sig53/' # train images (relative to '../path') 128 images +val: './wideband_sig53/' # val images (relative to '../path') 128 images -nc: 53 +nc: 6 # Classes + names: - 0: ook - 1: bpsk - 2: 4pam - 3: 4ask - 4: qpsk - 5: 8pam - 6: 8ask - 7: 8psk - 8: 16qam - 9: 16pam - 10: 16ask - 11: 16psk - 12: 32qam - 13: 32qam_cross - 14: 32pam - 15: 32ask - 16: 32psk - 17: 64qam - 18: 64pam - 19: 64ask - 20: 64psk - 21: 128qam_cross - 22: 256qam - 23: 512qam_cross - 24: 1024qam - 25: 2fsk - 26: 2gfsk - 27: 2msk - 28: 2gmsk - 29: 4fsk - 30: 4gfsk - 31: 4msk - 32: 4gmsk - 33: 8fsk - 34: 8gfsk - 35: 8msk - 36: 8gmsk - 37: 16fsk - 38: 16gfsk - 39: 16msk - 40: 16gmsk - 41: ofdm-64 - 42: ofdm-72 - 43: ofdm-128 - 44: ofdm-180 - 45: ofdm-256 - 46: ofdm-300 - 47: ofdm-512 - 48: ofdm-600 - 49: ofdm-900 - 50: ofdm-1024 - 51: ofdm-1200 - 52: ofdm-2048 - + 0: ask + 1: fsk + 2: ofdm + 3: pam + 4: psk + 5: qam \ No newline at end of file diff --git a/torchsig/transforms/target_transforms.py b/torchsig/transforms/target_transforms.py index 060a7be..0363222 100755 --- a/torchsig/transforms/target_transforms.py +++ b/torchsig/transforms/target_transforms.py @@ -1046,8 +1046,8 @@ def __call__(self, metadata: List[SignalMetadata]) -> Dict[str, torch.Tensor]: bandwidth: float = meta["upper_freq"] - meta["lower_freq"] boxes[meta_idx] = np.array( [ - meta["start"] + 0.5 * duration, - meta["lower_freq"] + 0.5 + 0.5 * bandwidth, + meta["start"] + (duration / 2), + meta["lower_freq"] + 0.5 + (bandwidth / 2), duration, bandwidth, ] diff --git a/torchsig/utils/classify_transforms.py b/torchsig/utils/classify_transforms.py index 086ef85..1d4251c 100644 --- a/torchsig/utils/classify_transforms.py +++ b/torchsig/utils/classify_transforms.py @@ -1,5 +1,7 @@ from scipy.signal import ShortTimeFFT from scipy.interpolate import interp1d +from scipy.ndimage import gaussian_filter +from scipy.interpolate import splrep, splev from PIL import Image import numpy as np import pywt @@ -59,57 +61,90 @@ def spectrogram_image(signal, nfft=64): return img +class PLL: + def __init__(self, sample_rate, loop_bandwidth, damping_factor): + self.sample_rate = sample_rate + self.loop_bandwidth = loop_bandwidth + self.damping_factor = damping_factor + self.phase_error_integral = 0 + self.omega = 2 * np.pi * self.loop_bandwidth + self.filter_alpha = 1 / (1 + (self.omega / (2 * np.pi * self.damping_factor))**2) + self.filter_beta = (self.filter_alpha ** 2) / (4 * self.damping_factor) + + def phase_detector(self, signal, reference): + """Compute the phase difference between the signal and the reference.""" + phase_diff = np.angle(signal * np.conj(reference)) + return phase_diff + + def loop_filter(self, phase_error): + """Apply a PI controller to the phase error.""" + proportional = self.filter_alpha * np.mean(phase_error) + integral = self.filter_beta * self.phase_error_integral + self.phase_error_integral += np.mean(phase_error) + control_signal = proportional + integral + return control_signal + + def vco(self, control_signal, length): + """Generate a signal with frequency adjusted by the control signal.""" + time = np.arange(length) / self.sample_rate + return np.exp(1j * (2 * np.pi * np.cumsum(np.full(length, control_signal)) / self.sample_rate)) + + def correct_signal(self, signal): + """Correct the input signal using the PLL.""" + reference = np.exp(1j * np.angle(signal)) # Initial reference + phase_error = self.phase_detector(signal, reference) + control_signal = self.loop_filter(phase_error) + corrected_signal = signal * np.conj(self.vco(control_signal, len(signal))) + return corrected_signal + def upsample_iq(iq, target_length): - # Separate real and imaginary components iqx, iqy = iq.real, iq.imag - - # Create a linear space for interpolation original_indices = np.arange(len(iq)) target_indices = np.linspace(0, len(iq) - 1, target_length) - # Interpolate real and imaginary parts - iqx_interp = interp1d(original_indices, iqx, kind='cubic')(target_indices) - iqy_interp = interp1d(original_indices, iqy, kind='cubic')(target_indices) + # Compute the spline representation for both real and imaginary parts + tck_iqx = splrep(original_indices, iqx, s=0) + tck_iqy = splrep(original_indices, iqy, s=0) + + # Evaluate the spline over the target indices + iqx_interp = splev(target_indices, tck_iqx, der=0) + iqy_interp = splev(target_indices, tck_iqy, der=0) # Recombine into a complex signal iq_upsampled = iqx_interp + 1j * iqy_interp return iq_upsampled -def complex_iq_to_heatmap(iq, output_size=[128, 128]): - # Calculate resolution based on the square root of the data length - resolution = int(np.sqrt(len(iq))) +def complex_iq_to_heatmap(iq, output_size=(224, 224), loop_bandwidth=1000, damping_factor=1, amp_factor=.5): + sample_rate = len(iq) + pll = PLL(sample_rate, loop_bandwidth, damping_factor) + iq_corrected = pll.correct_signal(iq) - # Calculate the target upsample length target_length = output_size[0] * output_size[1] + iq_upsampled = upsample_iq(iq_corrected, target_length) - # Upsample I/Q signal to match the output size dimensions - iq_upsampled = upsample_iq(iq, target_length) - - # Separate real and imaginary components iqx, iqy = iq_upsampled.real, iq_upsampled.imag - - # Normalize the real and imaginary components to [0, 1] iqx = (iqx - iqx.min()) / (iqx.max() - iqx.min() + 1e-8) iqy = (iqy - iqy.min()) / (iqy.max() - iqy.min() + 1e-8) - # Initialize an empty heatmap heatmap = np.zeros(output_size) - - # Map the I/Q values to the output size grid ix = (iqx * (output_size[1] - 1)).astype(int) iy = (iqy * (output_size[0] - 1)).astype(int) - # Accumulate counts in the heatmap np.add.at(heatmap, (iy, ix), 1) - # Normalize the heatmap to [0, 1] + heatmap = np.power(heatmap, amp_factor) + + # Apply Gaussian smoothing + heatmap = gaussian_filter(heatmap, sigma=1.0) + if heatmap.max() > 0: heatmap /= heatmap.max() - # Convert the heatmap to 8-bit for visualization heatmap_8bit = np.uint8(heatmap * 255) - # Apply a colormap to the heatmap using OpenCV + # Contrast adjustment + heatmap_8bit = cv2.equalizeHist(heatmap_8bit) + heatmap_colored = cv2.applyColorMap(heatmap_8bit, cv2.COLORMAP_TWILIGHT) return heatmap_colored diff --git a/torchsig/utils/dsp.py b/torchsig/utils/dsp.py index a0a63c4..6f2049a 100755 --- a/torchsig/utils/dsp.py +++ b/torchsig/utils/dsp.py @@ -4,6 +4,13 @@ def convolve(signal: np.ndarray, taps: np.ndarray) -> np.ndarray: + """A modified version of scipy.signal.convolve, which discards trasitional regions + + Args: + signal (np.ndarray): input signal to be filtered + taps (np.ndarray): filter with which to colvolve the signal + + """ filtered = sp.convolve(signal, taps, "full") lidx = (len(filtered) - len(signal)) // 2 ridx = lidx + len(signal) diff --git a/torchsig/utils/visualize.py b/torchsig/utils/visualize.py index d3fc89d..30f8306 100755 --- a/torchsig/utils/visualize.py +++ b/torchsig/utils/visualize.py @@ -9,6 +9,7 @@ import numpy as np import pywt import torch +import pdb class Visualizer: diff --git a/torchsig/utils/yolo_classify.py b/torchsig/utils/yolo_classify.py index 8ae5e99..08749df 100644 --- a/torchsig/utils/yolo_classify.py +++ b/torchsig/utils/yolo_classify.py @@ -49,7 +49,7 @@ def __init__(self, root, args, augment=False, image_transform=None): # Determine whether to map descriptions to family names if self.config['family']: - self.class_to_idx_dict = {v: k for k, v in self.config['family'].items()} + self.class_to_idx_dict = {v: k for k, v in self.config['families'].items()} target_transform = CP([DescToFamilyName()]) else: self.class_to_idx_dict = {v: k for k, v in self.config['names'].items()} @@ -61,7 +61,7 @@ def __init__(self, root, args, augment=False, image_transform=None): use_class_idx=False, level=self.config['level'], num_iq_samples=args.imgsz**2, - num_samples=int(self.config['nc'] * 1000), + num_samples=self.config['num_samples'], include_snr=self.config['include_snr'], target_transform=target_transform ) @@ -197,8 +197,11 @@ def get_dataset(self): """ with open(self.args.data, 'r') as file: config = yaml.safe_load(file) - names = config['names'] - nc = config['nc'] + if config['family']: + names = config['families'] + else: + names = config['names'] + nc = len(names) data = {"train": self.args.data, "val": self.args.data, "test": self.args.data, "nc": nc, "names": names} self.data = data return data["train"], data.get("val") or data.get("test") diff --git a/torchsig/utils/yolo_train.py b/torchsig/utils/yolo_train.py index 0257d4a..09a67ed 100644 --- a/torchsig/utils/yolo_train.py +++ b/torchsig/utils/yolo_train.py @@ -1,4 +1,4 @@ -from torchsig.transforms.target_transforms import DescToBBoxYoloSignalDict +from torchsig.transforms.target_transforms import DescToBBoxYoloSignalDict, DescToBBoxFamilyDict from torchsig.transforms import Spectrogram, Normalize, SpectrogramImage from torchsig.datasets.wideband_sig53 import WidebandSig53 from torchsig.transforms.transforms import Compose as CP @@ -50,7 +50,8 @@ def __init__(self, *args, mode='train', imgsz=640, hyp=DEFAULT_CFG, data=None, t # Define the transformation for converting description to bounding boxes target_transform = CP([ - DescToBBoxYoloSignalDict() + # DescToBBoxYoloSignalDict() + DescToBBoxFamilyDict() ]) # Initialize the WidebandSig53 dataset with the defined transforms