Upload 4 files

inference.py

@@ -1,85 +1,85 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Sun Sep 15 18:27:17 2024
-
-@author: salikha4
-"""
-
-import os
-import csv
-import json
-import shutil
-import random
-import argparse
-from datetime import datetime
-import pandas as pd
-import time
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.utils.data import Dataset, DataLoader, TensorDataset
-from torch.optim import Adam
-import numpy as np
-import warnings
-warnings.filterwarnings('ignore')
-
-def lwm_inference(preprocessed_chs, input_type, lwm_model, device):
-    
-    dataset = prepare_for_lwm(preprocessed_chs, device)
-    # Process data through LWM
-    lwm_loss, embedding_data = evaluate(lwm_model, dataset)
-    print(f'LWM loss: {lwm_loss:.4f}')
-    
-    if input_type == 'cls_emb':
-        embedding_data = embedding_data[:, 0]
-    elif input_type == 'channel_emb':  
-        embedding_data = embedding_data[:, 1:]
-    
-    dataset = embedding_data.float()
-    return dataset
-
-def prepare_for_lwm(data, device, batch_size=64, shuffle=False):
-
-    input_ids, masked_tokens, masked_pos = zip(*data)
-    
-    input_ids_tensor = torch.tensor(input_ids, device=device).float() 
-    masked_tokens_tensor = torch.tensor(masked_tokens, device=device).float() 
-    masked_pos_tensor = torch.tensor(masked_pos, device=device).long()
-
-    dataset = TensorDataset(input_ids_tensor, masked_tokens_tensor, masked_pos_tensor)
-    
-    return DataLoader(dataset, batch_size=batch_size, shuffle=shuffle)
-
-def evaluate(model, dataloader):
-
-    model.eval()
-    running_loss = 0.0
-    outputs = []
-    criterionMCM = nn.MSELoss()
-    
-    with torch.no_grad():
-        for idx, batch in enumerate(dataloader):
-            input_ids = batch[0]
-            masked_tokens = batch[1]
-            masked_pos = batch[2]
-
-            logits_lm, output = model(input_ids, masked_pos)
-            
-            output_batch_preproc = output 
-            outputs.append(output_batch_preproc)
-
-            loss_lm = criterionMCM(logits_lm, masked_tokens)
-            loss = loss_lm / torch.var(masked_tokens)  
-            running_loss += loss.item()
-            
-    average_loss = running_loss / len(dataloader)
-    output_total = torch.cat(outputs, dim=0)
-    
-    return average_loss, output_total
-
-def create_raw_dataset(data, device):
-    """Create a dataset for raw channel data."""
-    input_ids, _, _ = zip(*data)
-    input_data = torch.tensor(input_ids, device=device)[:, 1:]  
-    return input_data.float()
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Sep 15 18:27:17 2024
+
+@author: salikha4
+"""
+
+import os
+import csv
+import json
+import shutil
+import random
+import argparse
+from datetime import datetime
+import pandas as pd
+import time
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader, TensorDataset
+from torch.optim import Adam
+import numpy as np
+import warnings
+warnings.filterwarnings('ignore')
+
+def lwm_inference(preprocessed_chs, input_type, lwm_model, device):
+    
+    dataset = prepare_for_lwm(preprocessed_chs, device)
+    # Process data through LWM
+    lwm_loss, embedding_data = evaluate(lwm_model, dataset)
+    # print(f'LWM loss: {lwm_loss:.4f}')
+    
+    if input_type == 'cls_emb':
+        embedding_data = embedding_data[:, 0]
+    elif input_type == 'channel_emb':  
+        embedding_data = embedding_data[:, 1:]
+    
+    dataset = embedding_data.float()
+    return dataset
+
+def prepare_for_lwm(data, device, batch_size=64, shuffle=False):
+
+    input_ids, masked_tokens, masked_pos = zip(*data)
+    
+    input_ids_tensor = torch.tensor(input_ids, device=device).float() 
+    masked_tokens_tensor = torch.tensor(masked_tokens, device=device).float() 
+    masked_pos_tensor = torch.tensor(masked_pos, device=device).long()
+
+    dataset = TensorDataset(input_ids_tensor, masked_tokens_tensor, masked_pos_tensor)
+    
+    return DataLoader(dataset, batch_size=batch_size, shuffle=shuffle)
+
+def evaluate(model, dataloader):
+
+    model.eval()
+    running_loss = 0.0
+    outputs = []
+    criterionMCM = nn.MSELoss()
+    
+    with torch.no_grad():
+        for idx, batch in enumerate(dataloader):
+            input_ids = batch[0]
+            masked_tokens = batch[1]
+            masked_pos = batch[2]
+
+            logits_lm, output = model(input_ids, masked_pos)
+            
+            output_batch_preproc = output 
+            outputs.append(output_batch_preproc)
+
+            loss_lm = criterionMCM(logits_lm, masked_tokens)
+            loss = loss_lm / torch.var(masked_tokens)  
+            running_loss += loss.item()
+            
+    average_loss = running_loss / len(dataloader)
+    output_total = torch.cat(outputs, dim=0)
+    
+    return average_loss, output_total
+
+def create_raw_dataset(data, device):
+    """Create a dataset for raw channel data."""
+    input_ids, _, _ = zip(*data)
+    input_data = torch.tensor(input_ids, device=device)[:, 1:]  
+    return input_data.float()
     

input_preprocess.py

@@ -1,374 +1,373 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Fri Sep 13 16:13:29 2024
-
-This script generates preprocessed data from wireless communication scenarios, 
-including token generation, patch creation, and data sampling for machine learning models.
-
-@author: salikha4
-"""
-
-import numpy as np
-import os
-from tqdm import tqdm
-import time
-import pickle
-import DeepMIMOv3
-import torch
-
-#%% Scenarios List
-def scenarios_list():
-    """Returns an array of available scenarios."""
-    return np.array([
-        'city_18_denver', 'city_15_indianapolis', 'city_19_oklahoma', 
-        'city_12_fortworth', 'city_11_santaclara', 'city_7_sandiego'
-    ])
-
-#%% Token Generation
-def tokenizer(selected_scenario_names=None, manual_data=None, gen_raw=True):
-    """
-    Generates tokens by preparing and preprocessing the dataset.
-
-    Args:
-        scenario_idxs (list): Indices of the scenarios.
-        patch_gen (bool): Whether to generate patches. Defaults to True.
-        patch_size (int): Size of each patch. Defaults to 16.
-        gen_deepMIMO_data (bool): Whether to generate DeepMIMO data. Defaults to False.
-        gen_raw (bool): Whether to generate raw data. Defaults to False.
-        save_data (bool): Whether to save the preprocessed data. Defaults to False.
-    
-    Returns:
-        preprocessed_data, sequence_length, element_length: Preprocessed data and related dimensions.
-    """
-
-    if manual_data is not None:
-        patches = patch_maker(np.expand_dims(np.array(manual_data), axis=1))
-        #patches = patch_maker(torch.tensor(manual_data, dtype=torch.complex64).unsqueeze(1))
-    else:
-        # Patch generation or loading
-        if isinstance(selected_scenario_names, str):
-            selected_scenario_names = [selected_scenario_names]
-        deepmimo_data = [DeepMIMO_data_gen(scenario_name) for scenario_name in selected_scenario_names]
-
-        n_scenarios = len(selected_scenario_names)
-        
-        cleaned_deepmimo_data = [deepmimo_data_cleaning(deepmimo_data[scenario_idx]) for scenario_idx in range(n_scenarios)]
-        
-        patches = [patch_maker(cleaned_deepmimo_data[scenario_idx]) for scenario_idx in range(n_scenarios)]
-        patches = np.vstack(patches)
-
-    # Define dimensions
-    patch_size = patches.shape[2]
-    n_patches = patches.shape[1]
-    n_masks_half = int(0.15 * n_patches / 2)
-    # sequence_length = n_patches + 1
-    # element_length = patch_size
-    
-    word2id = {'[CLS]': 0.2 * np.ones((patch_size)), '[MASK]': 0.1 * np.ones((patch_size))}
-
-    # Generate preprocessed channels
-    preprocessed_data = []
-    for user_idx in tqdm(range(len(patches)), desc="Processing items"):
-        sample = make_sample(user_idx, patches, word2id, n_patches, n_masks_half, patch_size, gen_raw=gen_raw)
-        preprocessed_data.append(sample)
-            
-    return preprocessed_data
-
-#%%
-def deepmimo_data_cleaning(deepmimo_data):
-    idxs = np.where(deepmimo_data['user']['LoS'] != -1)[0]
-    cleaned_deepmimo_data = deepmimo_data['user']['channel'][idxs]
-    return np.array(cleaned_deepmimo_data) * 1e6
-
-#%% Patch Creation
-def patch_maker(original_ch, patch_size=16, norm_factor=1e6):
-    """
-    Creates patches from the dataset based on the scenario.
-
-    Args:-
-        patch_size (int): Size of each patch.
-        scenario (str): Selected scenario for data generation.
-        gen_deepMIMO_data (bool): Whether to generate DeepMIMO data.
-        norm_factor (int): Normalization factor for channels.
-
-    Returns:
-        patch (numpy array): Generated patches.
-    """
-    # idxs = np.where(data['user']['LoS'] != -1)[0]
-    
-    # # Reshaping and normalizing channels
-    # original_ch = data['user']['channel'][idxs]
-    flat_channels = original_ch.reshape((original_ch.shape[0], -1)).astype(np.csingle)
-    flat_channels_complex = np.hstack((flat_channels.real, flat_channels.imag))
-    
-    # Create patches
-    n_patches = flat_channels_complex.shape[1] // patch_size
-    patch = np.zeros((len(flat_channels_complex), n_patches, patch_size))
-    for idx in range(n_patches):
-        patch[:, idx, :] = flat_channels_complex[:, idx * patch_size:(idx + 1) * patch_size]
-    
-    return patch
-
-
-#%% Data Generation for Scenario Areas
-def DeepMIMO_data_gen(scenario):
-    """
-    Generates or loads data for a given scenario.
-
-    Args:
-        scenario (str): Scenario name.
-        gen_deepMIMO_data (bool): Whether to generate DeepMIMO data.
-        save_data (bool): Whether to save generated data.
-    
-    Returns:
-        data (dict): Loaded or generated data.
-    """
-    import DeepMIMOv3
-    
-    parameters, row_column_users, n_ant_bs, n_ant_ue, n_subcarriers = get_parameters(scenario)
-    
-    deepMIMO_dataset = DeepMIMOv3.generate_data(parameters)
-    uniform_idxs = uniform_sampling(deepMIMO_dataset, [1, 1], len(parameters['user_rows']), 
-                                    users_per_row=row_column_users[scenario]['n_per_row'])
-    data = select_by_idx(deepMIMO_dataset, uniform_idxs)[0]
-        
-    return data
-
-#%%%
-def get_parameters(scenario):
-    
-    n_ant_bs = 32 #32
-    n_ant_ue = 1
-    n_subcarriers = 32 #32
-    scs = 30e3
-        
-    row_column_users = {
-    'city_18_denver': {
-        'n_rows': 85,
-        'n_per_row': 82
-    },
-    'city_15_indianapolis': {
-        'n_rows': 80,
-        'n_per_row': 79
-    },
-    'city_19_oklahoma': {
-        'n_rows': 82,
-        'n_per_row': 75
-    },
-    'city_12_fortworth': {
-        'n_rows': 86,
-        'n_per_row': 72
-    },
-    'city_11_santaclara': {
-        'n_rows': 47,
-        'n_per_row': 114
-    },
-    'city_7_sandiego': {
-        'n_rows': 71,
-        'n_per_row': 83
-    }}
-    
-    parameters = DeepMIMOv3.default_params()
-    parameters['dataset_folder'] = './scenarios'
-    parameters['scenario'] = scenario
-    
-    if scenario == 'O1_3p5':
-        parameters['active_BS'] = np.array([4])
-    elif scenario in ['city_18_denver', 'city_15_indianapolis']:
-        parameters['active_BS'] = np.array([3])
-    else:
-        parameters['active_BS'] = np.array([1])
-        
-    if scenario == 'Boston5G_3p5':
-        parameters['user_rows'] = np.arange(row_column_users[scenario]['n_rows'][0],
-                                            row_column_users[scenario]['n_rows'][1])
-    else:
-        parameters['user_rows'] = np.arange(row_column_users[scenario]['n_rows'])
-    parameters['bs_antenna']['shape'] = np.array([n_ant_bs, 1]) # Horizontal, Vertical 
-    parameters['bs_antenna']['rotation'] = np.array([0,0,-135]) # (x,y,z)
-    parameters['ue_antenna']['shape'] = np.array([n_ant_ue, 1])
-    parameters['enable_BS2BS'] = False
-    parameters['OFDM']['subcarriers'] = n_subcarriers
-    parameters['OFDM']['selected_subcarriers'] = np.arange(n_subcarriers)
-    
-    parameters['OFDM']['bandwidth'] = scs * n_subcarriers / 1e9
-    parameters['num_paths'] = 20
-    
-    return parameters, row_column_users, n_ant_bs, n_ant_ue, n_subcarriers
-
-#%% Sample Generation
-def make_sample(user_idx, patch, word2id, n_patches, n_masks, patch_size, gen_raw=False):
-    """
-    Generates a sample for each user, including masking and tokenizing.
-
-    Args:
-        user_idx (int): Index of the user.
-        patch (numpy array): Patches data.
-        word2id (dict): Dictionary for special tokens.
-        n_patches (int): Number of patches.
-        n_masks (int): Number of masks.
-        patch_size (int): Size of each patch.
-        gen_raw (bool): Whether to generate raw tokens.
-
-    Returns:
-        sample (list): Generated sample for the user.
-    """
-    
-    tokens = patch[user_idx]
-    input_ids = np.vstack((word2id['[CLS]'], tokens))
-    
-    real_tokens_size = int(n_patches / 2)
-    masks_pos_real = np.random.choice(range(0, real_tokens_size), size=n_masks, replace=False)
-    masks_pos_imag = masks_pos_real + real_tokens_size
-    masked_pos = np.hstack((masks_pos_real, masks_pos_imag)) + 1
-    
-    masked_tokens = []
-    for pos in masked_pos:
-        original_masked_tokens = input_ids[pos].copy()
-        masked_tokens.append(original_masked_tokens)
-        if not gen_raw:
-            rnd_num = np.random.rand()
-            if rnd_num < 0.1:
-                input_ids[pos] = np.random.rand(patch_size)
-            elif rnd_num < 0.9:
-                input_ids[pos] = word2id['[MASK]']
-                
-    return [input_ids, masked_tokens, masked_pos]
-
-
-#%% Sampling and Data Selection
-def uniform_sampling(dataset, sampling_div, n_rows, users_per_row):
-    """
-    Performs uniform sampling on the dataset.
-
-    Args:
-        dataset (dict): DeepMIMO dataset.
-        sampling_div (list): Step sizes along [x, y] dimensions.
-        n_rows (int): Number of rows for user selection.
-        users_per_row (int): Number of users per row.
-
-    Returns:
-        uniform_idxs (numpy array): Indices of the selected samples.
-    """
-    cols = np.arange(users_per_row, step=sampling_div[0])
-    rows = np.arange(n_rows, step=sampling_div[1])
-    uniform_idxs = np.array([j + i * users_per_row for i in rows for j in cols])
-    
-    return uniform_idxs
-
-def select_by_idx(dataset, idxs):
-    """
-    Selects a subset of the dataset based on the provided indices.
-
-    Args:
-        dataset (dict): Dataset to trim.
-        idxs (numpy array): Indices of users to select.
-
-    Returns:
-        dataset_t (list): Trimmed dataset based on selected indices.
-    """
-    dataset_t = []  # Trimmed dataset
-    for bs_idx in range(len(dataset)):
-        dataset_t.append({})
-        for key in dataset[bs_idx].keys():
-            dataset_t[bs_idx]['location'] = dataset[bs_idx]['location']
-            dataset_t[bs_idx]['user'] = {k: dataset[bs_idx]['user'][k][idxs] for k in dataset[bs_idx]['user']}
-    
-    return dataset_t
-
-#%% Save and Load Utilities
-def save_var(var, path):
-    """
-    Saves a variable to a pickle file.
-
-    Args:
-        var (object): Variable to be saved.
-        path (str): Path to save the file.
-
-    Returns:
-        None
-    """
-    path_full = path if path.endswith('.p') else (path + '.pickle')    
-    with open(path_full, 'wb') as handle:
-        pickle.dump(var, handle)
-
-def load_var(path):
-    """
-    Loads a variable from a pickle file.
-
-    Args:
-        path (str): Path of the file to load.
-
-    Returns:
-        var (object): Loaded variable.
-    """
-    path_full = path if path.endswith('.p') else (path + '.pickle')
-    with open(path_full, 'rb') as handle:
-        var = pickle.load(handle)
-    
-    return var
-
-#%% Label Generation
-def label_gen(task, data, scenario, n_beams=64):
-    
-    idxs = np.where(data['user']['LoS'] != -1)[0]
-            
-    if task == 'LoS/NLoS Classification':
-        label = data['user']['LoS'][idxs]
-    elif task == 'Beam Prediction':
-        parameters, row_column_users, n_ant_bs, n_ant_ue, n_subcarriers = get_parameters(scenario)
-        n_users = len(data['user']['channel'])
-        n_subbands = 1
-        fov = 120
-
-        # Setup Beamformers
-        beam_angles = np.around(np.arange(-fov/2, fov/2+.1, fov/(n_beams-1)), 2)
-
-        F1 = np.array([steering_vec(parameters['bs_antenna']['shape'], 
-                                    phi=azi*np.pi/180, 
-                                    kd=2*np.pi*parameters['bs_antenna']['spacing']).squeeze()
-                       for azi in beam_angles])
-
-        full_dbm = np.zeros((n_beams, n_subbands, n_users), dtype=float)
-        for ue_idx in tqdm(range(n_users), desc='Computing the channel for each user'):
-            if data['user']['LoS'][ue_idx] == -1:
-                full_dbm[:,:,ue_idx] = np.nan
-            else:
-                chs = F1 @ data['user']['channel'][ue_idx]
-                full_linear = np.abs(np.mean(chs.squeeze().reshape((n_beams, n_subbands, -1)), axis=-1))
-                full_dbm[:,:,ue_idx] = np.around(20*np.log10(full_linear) + 30, 1)
-
-        best_beams = np.argmax(np.mean(full_dbm,axis=1), axis=0)
-        best_beams = best_beams.astype(float)
-        best_beams[np.isnan(full_dbm[0,0,:])] = np.nan
-        # max_bf_pwr = np.max(np.mean(full_dbm,axis=1), axis=0) 
-    
-        label = best_beams[idxs]
-        
-    return label.astype(int)
-
-def steering_vec(array, phi=0, theta=0, kd=np.pi):
-    idxs = DeepMIMOv3.ant_indices(array)
-    resp = DeepMIMOv3.array_response(idxs, phi, theta+np.pi/2, kd)
-    return resp / np.linalg.norm(resp)
-
-def label_prepend(deepmimo_data, preprocessed_chs, task, scenario_idxs, n_beams=64):
-    labels = []
-    for scenario_idx in scenario_idxs:
-        scenario_name = scenarios_list()[scenario_idx]
-        # data = DeepMIMO_data_gen(scenario_name)
-        data = deepmimo_data[scenario_idx]
-        labels.extend(label_gen(task, data, scenario_name, n_beams=n_beams))
-    
-    preprocessed_chs = [preprocessed_chs[i] + [labels[i]] for i in range(len(preprocessed_chs))]
-    
-    return preprocessed_chs
-
-def create_labels(task, scenario_names, n_beams=64):
-    labels = []
-    if isinstance(scenario_names, str):
-        scenario_names = [scenario_names]
-    for scenario_name in scenario_names:
-        data = DeepMIMO_data_gen(scenario_name)
-        labels.extend(label_gen(task, data, scenario_name, n_beams=n_beams))
-    return torch.tensor(labels)
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Sep 13 16:13:29 2024
+
+This script generates preprocessed data from wireless communication scenarios, 
+including token generation, patch creation, and data sampling for machine learning models.
+
+@author: salikha4
+"""
+
+import numpy as np
+import os
+from tqdm import tqdm
+import time
+import pickle
+import DeepMIMOv3
+import torch
+from utils import plot_coverage, generate_gaussian_noise
+#%% Scenarios List
+def scenarios_list():
+    """Returns an array of available scenarios."""
+    return np.array([
+        'city_18_denver', 'city_15_indianapolis', 'city_19_oklahoma', 
+        'city_12_fortworth', 'city_11_santaclara', 'city_7_sandiego'
+    ])
+
+#%% Token Generation
+def tokenizer(selected_scenario_names=None, manual_data=None, gen_raw=True, snr_db=None):
+    """
+    Generates tokens by preparing and preprocessing the dataset.
+
+    Args:
+        scenario_idxs (list): Indices of the scenarios.
+        patch_gen (bool): Whether to generate patches. Defaults to True.
+        patch_size (int): Size of each patch. Defaults to 16.
+        gen_deepMIMO_data (bool): Whether to generate DeepMIMO data. Defaults to False.
+        gen_raw (bool): Whether to generate raw data. Defaults to False.
+        save_data (bool): Whether to save the preprocessed data. Defaults to False.
+    
+    Returns:
+        preprocessed_data, sequence_length, element_length: Preprocessed data and related dimensions.
+    """
+
+    if manual_data is not None:
+        patches = patch_maker(np.expand_dims(np.array(manual_data), axis=1), snr_db=snr_db)
+    else:
+        # Patch generation or loading
+        if isinstance(selected_scenario_names, str):
+            selected_scenario_names = [selected_scenario_names]
+        deepmimo_data = [DeepMIMO_data_gen(scenario_name) for scenario_name in selected_scenario_names]
+        n_scenarios = len(selected_scenario_names)
+        
+        cleaned_deepmimo_data = [deepmimo_data_cleaning(deepmimo_data[scenario_idx]) for scenario_idx in range(n_scenarios)]
+        
+        patches = [patch_maker(cleaned_deepmimo_data[scenario_idx], snr_db=snr_db) for scenario_idx in range(n_scenarios)]
+        patches = np.vstack(patches)
+
+    # Define dimensions
+    patch_size = patches.shape[2]
+    n_patches = patches.shape[1]
+    n_masks_half = int(0.15 * n_patches / 2)
+    
+    word2id = {'[CLS]': 0.2 * np.ones((patch_size)), '[MASK]': 0.1 * np.ones((patch_size))}
+
+    # Generate preprocessed channels
+    preprocessed_data = []
+    for user_idx in tqdm(range(len(patches)), desc="Processing items"):
+        sample = make_sample(user_idx, patches, word2id, n_patches, n_masks_half, patch_size, gen_raw=gen_raw)
+        preprocessed_data.append(sample)
+            
+    return preprocessed_data
+
+#%%
+def deepmimo_data_cleaning(deepmimo_data):
+    idxs = np.where(deepmimo_data['user']['LoS'] != -1)[0]
+    cleaned_deepmimo_data = deepmimo_data['user']['channel'][idxs]
+    return np.array(cleaned_deepmimo_data) * 1e6
+
+#%% Patch Creation
+def patch_maker(original_ch, patch_size=16, norm_factor=1e6, snr_db=None):
+    """
+    Creates patches from the dataset based on the scenario.
+
+    Args:-
+        patch_size (int): Size of each patch.
+        scenario (str): Selected scenario for data generation.
+        gen_deepMIMO_data (bool): Whether to generate DeepMIMO data.
+        norm_factor (int): Normalization factor for channels.
+
+    Returns:
+        patch (numpy array): Generated patches.
+    """
+    flat_channels = original_ch.reshape((original_ch.shape[0], -1)).astype(np.csingle)
+    if snr_db is not None:
+        flat_channels += generate_gaussian_noise(flat_channels, snr_db)
+        
+    flat_channels_complex = np.hstack((flat_channels.real, flat_channels.imag))
+        
+    # Create patches
+    n_patches = flat_channels_complex.shape[1] // patch_size
+    patch = np.zeros((len(flat_channels_complex), n_patches, patch_size))
+    for idx in range(n_patches):
+        patch[:, idx, :] = flat_channels_complex[:, idx * patch_size:(idx + 1) * patch_size]
+    
+    return patch
+
+#%% Data Generation for Scenario Areas
+def DeepMIMO_data_gen(scenario):
+    """
+    Generates or loads data for a given scenario.
+
+    Args:
+        scenario (str): Scenario name.
+        gen_deepMIMO_data (bool): Whether to generate DeepMIMO data.
+        save_data (bool): Whether to save generated data.
+    
+    Returns:
+        data (dict): Loaded or generated data.
+    """
+    import DeepMIMOv3
+    
+    parameters, row_column_users, n_ant_bs, n_ant_ue, n_subcarriers = get_parameters(scenario)
+    
+    deepMIMO_dataset = DeepMIMOv3.generate_data(parameters)
+    uniform_idxs = uniform_sampling(deepMIMO_dataset, [1, 1], len(parameters['user_rows']), 
+                                    users_per_row=row_column_users[scenario]['n_per_row'])
+    data = select_by_idx(deepMIMO_dataset, uniform_idxs)[0]
+        
+    return data
+
+#%%%
+def get_parameters(scenario):
+    
+    n_ant_bs = 32 
+    n_ant_ue = 1
+    n_subcarriers = 32 
+    scs = 30e3
+        
+    row_column_users = {
+    'city_18_denver': {
+        'n_rows': 85,
+        'n_per_row': 82
+    },
+    'city_15_indianapolis': {
+        'n_rows': 80,
+        'n_per_row': 79
+    },
+    'city_19_oklahoma': {
+        'n_rows': 82,
+        'n_per_row': 75
+    },
+    'city_12_fortworth': {
+        'n_rows': 86,
+        'n_per_row': 72
+    },
+    'city_11_santaclara': {
+        'n_rows': 47,
+        'n_per_row': 114
+    },
+    'city_7_sandiego': {
+        'n_rows': 71,
+        'n_per_row': 83
+    }}
+    
+    parameters = DeepMIMOv3.default_params()
+    parameters['dataset_folder'] = './scenarios'
+    parameters['scenario'] = scenario
+    
+    if scenario == 'O1_3p5':
+        parameters['active_BS'] = np.array([4])
+    elif scenario in ['city_18_denver', 'city_15_indianapolis']:
+        parameters['active_BS'] = np.array([3])
+    else:
+        parameters['active_BS'] = np.array([1])
+        
+    if scenario == 'Boston5G_3p5':
+        parameters['user_rows'] = np.arange(row_column_users[scenario]['n_rows'][0],
+                                            row_column_users[scenario]['n_rows'][1])
+    else:
+        parameters['user_rows'] = np.arange(row_column_users[scenario]['n_rows'])
+    parameters['bs_antenna']['shape'] = np.array([n_ant_bs, 1]) # Horizontal, Vertical 
+    parameters['bs_antenna']['rotation'] = np.array([0,0,-135]) # (x,y,z)
+    parameters['ue_antenna']['shape'] = np.array([n_ant_ue, 1])
+    parameters['enable_BS2BS'] = False
+    parameters['OFDM']['subcarriers'] = n_subcarriers
+    parameters['OFDM']['selected_subcarriers'] = np.arange(n_subcarriers)
+    
+    parameters['OFDM']['bandwidth'] = scs * n_subcarriers / 1e9
+    parameters['num_paths'] = 20
+    
+    return parameters, row_column_users, n_ant_bs, n_ant_ue, n_subcarriers
+
+#%% Sample Generation
+def make_sample(user_idx, patch, word2id, n_patches, n_masks, patch_size, gen_raw=False):
+    """
+    Generates a sample for each user, including masking and tokenizing.
+
+    Args:
+        user_idx (int): Index of the user.
+        patch (numpy array): Patches data.
+        word2id (dict): Dictionary for special tokens.
+        n_patches (int): Number of patches.
+        n_masks (int): Number of masks.
+        patch_size (int): Size of each patch.
+        gen_raw (bool): Whether to generate raw tokens.
+
+    Returns:
+        sample (list): Generated sample for the user.
+    """
+    
+    tokens = patch[user_idx]
+    input_ids = np.vstack((word2id['[CLS]'], tokens))
+    
+    real_tokens_size = int(n_patches / 2)
+    masks_pos_real = np.random.choice(range(0, real_tokens_size), size=n_masks, replace=False)
+    masks_pos_imag = masks_pos_real + real_tokens_size
+    masked_pos = np.hstack((masks_pos_real, masks_pos_imag)) + 1
+    
+    masked_tokens = []
+    for pos in masked_pos:
+        original_masked_tokens = input_ids[pos].copy()
+        masked_tokens.append(original_masked_tokens)
+        if not gen_raw:
+            rnd_num = np.random.rand()
+            if rnd_num < 0.1:
+                input_ids[pos] = np.random.rand(patch_size)
+            elif rnd_num < 0.9:
+                input_ids[pos] = word2id['[MASK]']
+                
+    return [input_ids, masked_tokens, masked_pos]
+
+
+#%% Sampling and Data Selection
+def uniform_sampling(dataset, sampling_div, n_rows, users_per_row):
+    """
+    Performs uniform sampling on the dataset.
+
+    Args:
+        dataset (dict): DeepMIMO dataset.
+        sampling_div (list): Step sizes along [x, y] dimensions.
+        n_rows (int): Number of rows for user selection.
+        users_per_row (int): Number of users per row.
+
+    Returns:
+        uniform_idxs (numpy array): Indices of the selected samples.
+    """
+    cols = np.arange(users_per_row, step=sampling_div[0])
+    rows = np.arange(n_rows, step=sampling_div[1])
+    uniform_idxs = np.array([j + i * users_per_row for i in rows for j in cols])
+    
+    return uniform_idxs
+
+def select_by_idx(dataset, idxs):
+    """
+    Selects a subset of the dataset based on the provided indices.
+
+    Args:
+        dataset (dict): Dataset to trim.
+        idxs (numpy array): Indices of users to select.
+
+    Returns:
+        dataset_t (list): Trimmed dataset based on selected indices.
+    """
+    dataset_t = []  # Trimmed dataset
+    for bs_idx in range(len(dataset)):
+        dataset_t.append({})
+        for key in dataset[bs_idx].keys():
+            dataset_t[bs_idx]['location'] = dataset[bs_idx]['location']
+            dataset_t[bs_idx]['user'] = {k: dataset[bs_idx]['user'][k][idxs] for k in dataset[bs_idx]['user']}
+    
+    return dataset_t
+
+#%% Save and Load Utilities
+def save_var(var, path):
+    """
+    Saves a variable to a pickle file.
+
+    Args:
+        var (object): Variable to be saved.
+        path (str): Path to save the file.
+
+    Returns:
+        None
+    """
+    path_full = path if path.endswith('.p') else (path + '.pickle')    
+    with open(path_full, 'wb') as handle:
+        pickle.dump(var, handle)
+
+def load_var(path):
+    """
+    Loads a variable from a pickle file.
+
+    Args:
+        path (str): Path of the file to load.
+
+    Returns:
+        var (object): Loaded variable.
+    """
+    path_full = path if path.endswith('.p') else (path + '.pickle')
+    with open(path_full, 'rb') as handle:
+        var = pickle.load(handle)
+    
+    return var
+
+#%% Label Generation
+def label_gen(task, data, scenario, n_beams=64):
+    
+    idxs = np.where(data['user']['LoS'] != -1)[0]
+            
+    if task == 'LoS/NLoS Classification':
+        label = data['user']['LoS'][idxs]
+        
+        losChs = np.where(data['user']['LoS'] == -1, np.nan, data['user']['LoS'])
+        plot_coverage(data['user']['location'], losChs)
+        
+    elif task == 'Beam Prediction':
+        parameters, row_column_users = get_parameters(scenario)[:2]
+        n_users = len(data['user']['channel'])
+        n_subbands = 1
+        fov = 180
+
+        # Setup Beamformers
+        beam_angles = np.around(np.arange(-fov/2, fov/2+.1, fov/(n_beams-1)), 2)
+
+        F1 = np.array([steering_vec(parameters['bs_antenna']['shape'], 
+                                    phi=azi*np.pi/180, 
+                                    kd=2*np.pi*parameters['bs_antenna']['spacing']).squeeze()
+                       for azi in beam_angles])
+
+        full_dbm = np.zeros((n_beams, n_subbands, n_users), dtype=float)
+        for ue_idx in tqdm(range(n_users), desc='Computing the channel for each user'):
+            if data['user']['LoS'][ue_idx] == -1:
+                full_dbm[:,:,ue_idx] = np.nan
+            else:
+                chs = F1 @ data['user']['channel'][ue_idx]
+                full_linear = np.abs(np.mean(chs.squeeze().reshape((n_beams, n_subbands, -1)), axis=-1))
+                full_dbm[:,:,ue_idx] = np.around(20*np.log10(full_linear) + 30, 1)
+
+        best_beams = np.argmax(np.mean(full_dbm,axis=1), axis=0)
+        best_beams = best_beams.astype(float)
+        best_beams[np.isnan(full_dbm[0,0,:])] = np.nan
+        
+        plot_coverage(data['user']['location'], best_beams)
+        
+        label = best_beams[idxs]
+        
+    return label.astype(int)
+
+def steering_vec(array, phi=0, theta=0, kd=np.pi):
+    idxs = DeepMIMOv3.ant_indices(array)
+    resp = DeepMIMOv3.array_response(idxs, phi, theta+np.pi/2, kd)
+    return resp / np.linalg.norm(resp)
+
+def label_prepend(deepmimo_data, preprocessed_chs, task, scenario_idxs, n_beams=64):
+    labels = []
+    for scenario_idx in scenario_idxs:
+        scenario_name = scenarios_list()[scenario_idx]
+        data = deepmimo_data[scenario_idx]
+        labels.extend(label_gen(task, data, scenario_name, n_beams=n_beams))
+    
+    preprocessed_chs = [preprocessed_chs[i] + [labels[i]] for i in range(len(preprocessed_chs))]
+    
+    return preprocessed_chs
+
+def create_labels(task, scenario_names, n_beams=64):
+    labels = []
+    if isinstance(scenario_names, str):
+        scenario_names = [scenario_names]
+    for scenario_name in scenario_names:
+        data = DeepMIMO_data_gen(scenario_name)
+        labels.extend(label_gen(task, data, scenario_name, n_beams=n_beams))
+    return torch.tensor(labels).long()
+#%%

lwm_model.py

@@ -1,134 +1,134 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import numpy as np
-
-ELEMENT_LENGTH = 16
-D_MODEL = 64
-MAX_LEN = 129
-N_LAYERS = 12
-N_HEADS = 12
-D_FF = D_MODEL * 4
-D_K = D_MODEL // N_HEADS
-D_V = D_MODEL // N_HEADS
-DROPOUT = 0.1
-
-class LayerNormalization(nn.Module):
-    def __init__(self, d_model: int, eps: float = 1e-6) -> None:
-        super().__init__()
-        self.eps = eps
-        self.alpha = nn.Parameter(torch.ones(d_model))
-        self.bias = nn.Parameter(torch.zeros(d_model))
-
-    def forward(self, x):
-        mean = x.mean(dim=-1, keepdim=True)
-        std = x.std(dim=-1, keepdim=True)
-        return self.alpha * (x - mean) / (std + self.eps) + self.bias
-
-class Embedding(nn.Module):
-    def __init__(self, element_length, d_model, max_len):
-        super().__init__()
-        self.element_length = element_length
-        self.d_model = d_model
-        self.proj = nn.Linear(element_length, d_model)
-        self.pos_embed = nn.Embedding(max_len, d_model)
-        self.norm = LayerNormalization(d_model)
-
-    def forward(self, x):
-        seq_len = x.size(1)
-        pos = torch.arange(seq_len, dtype=torch.long, device=x.device)
-        pos = pos.unsqueeze(0).expand_as(x[:, :, 0])
-        tok_emb = self.proj(x.float())  
-        embedding = tok_emb + self.pos_embed(pos)
-        return self.norm(embedding)
-
-class ScaledDotProductAttention(nn.Module):
-    def __init__(self):
-        super().__init__()
-
-    def forward(self, Q, K, V):
-        scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(D_K)
-        attn = F.softmax(scores, dim=-1)
-        context = torch.matmul(attn, V)
-        return context, attn
-
-class MultiHeadAttention(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.W_Q = nn.Linear(D_MODEL, D_K * N_HEADS)
-        self.W_K = nn.Linear(D_MODEL, D_K * N_HEADS)
-        self.W_V = nn.Linear(D_MODEL, D_V * N_HEADS)
-        self.linear = nn.Linear(N_HEADS * D_V, D_MODEL)
-        self.norm = LayerNormalization(D_MODEL)
-        self.dropout = nn.Dropout(DROPOUT)
-        
-    def forward(self, Q, K, V):
-        residual, batch_size = Q, Q.size(0)
-        q_s = self.W_Q(Q).view(batch_size, -1, N_HEADS, D_K).transpose(1, 2)
-        k_s = self.W_K(K).view(batch_size, -1, N_HEADS, D_K).transpose(1, 2)
-        v_s = self.W_V(V).view(batch_size, -1, N_HEADS, D_V).transpose(1, 2)
-
-        context, attn = ScaledDotProductAttention()(q_s, k_s, v_s)
-        output = context.transpose(1, 2).contiguous().view(batch_size, -1, N_HEADS * D_V)
-        output = self.linear(output)
-        return residual + self.dropout(output), attn
-
-class PoswiseFeedForwardNet(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.fc1 = nn.Linear(D_MODEL, D_FF)
-        self.fc2 = nn.Linear(D_FF, D_MODEL)
-        self.dropout = nn.Dropout(DROPOUT)
-        self.norm = LayerNormalization(D_MODEL)
-
-    def forward(self, x):
-        output = self.fc2(self.dropout(F.relu(self.fc1(x))))
-        return x + self.dropout(output)
-
-class EncoderLayer(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.enc_self_attn = MultiHeadAttention()
-        self.pos_ffn = PoswiseFeedForwardNet()
-        self.norm = LayerNormalization(D_MODEL)
-
-    def forward(self, enc_inputs):
-        attn_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs)
-        attn_outputs = self.norm(attn_outputs)
-        enc_outputs = self.pos_ffn(attn_outputs)
-        return enc_outputs, attn
-
-class lwm(torch.nn.Module):
-    def __init__(self, element_length=16, d_model=64, max_len=129, n_layers=12):
-        super().__init__()
-        self.embedding = Embedding(element_length, d_model, max_len)
-        self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])
-        self.linear = nn.Linear(d_model, d_model)
-        self.norm = LayerNormalization(d_model)
-
-        embed_weight = self.embedding.proj.weight
-        d_model, n_dim = embed_weight.size()
-        self.decoder = nn.Linear(d_model, n_dim, bias=False)
-        self.decoder_bias = nn.Parameter(torch.zeros(n_dim))
-
-    @classmethod
-    def from_pretrained(cls, ckpt_name='model_weights.pth', device='cuda', use_auth_token=None):
-        model = cls().to(device)
-
-        ckpt_path = ckpt_name
-        model.load_state_dict(torch.load(ckpt_path, map_location=device))
-        print(f"Model loaded successfully from {ckpt_path} to {device}")
-
-        return model
-
-    def forward(self, input_ids, masked_pos):
-        output = self.embedding(input_ids)
-        for layer in self.layers:
-            output, _ = layer(output)
-
-        masked_pos = masked_pos.long()[:, :, None].expand(-1, -1, output.size(-1))
-        h_masked = torch.gather(output, 1, masked_pos)
-        h_masked = self.norm(F.relu(self.linear(h_masked)))
-        logits_lm = self.decoder(h_masked) + self.decoder_bias
-
-        return logits_lm, output
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+ELEMENT_LENGTH = 16
+D_MODEL = 64
+MAX_LEN = 129
+N_LAYERS = 12
+N_HEADS = 12
+D_FF = D_MODEL * 4
+D_K = D_MODEL // N_HEADS
+D_V = D_MODEL // N_HEADS
+DROPOUT = 0.1
+
+class LayerNormalization(nn.Module):
+    def __init__(self, d_model: int, eps: float = 1e-6) -> None:
+        super().__init__()
+        self.eps = eps
+        self.alpha = nn.Parameter(torch.ones(d_model))
+        self.bias = nn.Parameter(torch.zeros(d_model))
+
+    def forward(self, x):
+        mean = x.mean(dim=-1, keepdim=True)
+        std = x.std(dim=-1, keepdim=True)
+        return self.alpha * (x - mean) / (std + self.eps) + self.bias
+
+class Embedding(nn.Module):
+    def __init__(self, element_length, d_model, max_len):
+        super().__init__()
+        self.element_length = element_length
+        self.d_model = d_model
+        self.proj = nn.Linear(element_length, d_model)
+        self.pos_embed = nn.Embedding(max_len, d_model)
+        self.norm = LayerNormalization(d_model)
+
+    def forward(self, x):
+        seq_len = x.size(1)
+        pos = torch.arange(seq_len, dtype=torch.long, device=x.device)
+        pos = pos.unsqueeze(0).expand_as(x[:, :, 0])
+        tok_emb = self.proj(x.float())  
+        embedding = tok_emb + self.pos_embed(pos)
+        return self.norm(embedding)
+
+class ScaledDotProductAttention(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, Q, K, V):
+        scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(D_K)
+        attn = F.softmax(scores, dim=-1)
+        context = torch.matmul(attn, V)
+        return context, attn
+
+class MultiHeadAttention(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.W_Q = nn.Linear(D_MODEL, D_K * N_HEADS)
+        self.W_K = nn.Linear(D_MODEL, D_K * N_HEADS)
+        self.W_V = nn.Linear(D_MODEL, D_V * N_HEADS)
+        self.linear = nn.Linear(N_HEADS * D_V, D_MODEL)
+        self.norm = LayerNormalization(D_MODEL)
+        self.dropout = nn.Dropout(DROPOUT)
+        
+    def forward(self, Q, K, V):
+        residual, batch_size = Q, Q.size(0)
+        q_s = self.W_Q(Q).view(batch_size, -1, N_HEADS, D_K).transpose(1, 2)
+        k_s = self.W_K(K).view(batch_size, -1, N_HEADS, D_K).transpose(1, 2)
+        v_s = self.W_V(V).view(batch_size, -1, N_HEADS, D_V).transpose(1, 2)
+
+        context, attn = ScaledDotProductAttention()(q_s, k_s, v_s)
+        output = context.transpose(1, 2).contiguous().view(batch_size, -1, N_HEADS * D_V)
+        output = self.linear(output)
+        return residual + self.dropout(output), attn
+
+class PoswiseFeedForwardNet(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = nn.Linear(D_MODEL, D_FF)
+        self.fc2 = nn.Linear(D_FF, D_MODEL)
+        self.dropout = nn.Dropout(DROPOUT)
+        self.norm = LayerNormalization(D_MODEL)
+
+    def forward(self, x):
+        output = self.fc2(self.dropout(F.relu(self.fc1(x))))
+        return x + self.dropout(output)
+
+class EncoderLayer(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.enc_self_attn = MultiHeadAttention()
+        self.pos_ffn = PoswiseFeedForwardNet()
+        self.norm = LayerNormalization(D_MODEL)
+
+    def forward(self, enc_inputs):
+        attn_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs)
+        attn_outputs = self.norm(attn_outputs)
+        enc_outputs = self.pos_ffn(attn_outputs)
+        return enc_outputs, attn
+
+class lwm(torch.nn.Module):
+    def __init__(self, element_length=16, d_model=64, max_len=129, n_layers=12):
+        super().__init__()
+        self.embedding = Embedding(element_length, d_model, max_len)
+        self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])
+        self.linear = nn.Linear(d_model, d_model)
+        self.norm = LayerNormalization(d_model)
+
+        embed_weight = self.embedding.proj.weight
+        d_model, n_dim = embed_weight.size()
+        self.decoder = nn.Linear(d_model, n_dim, bias=False)
+        self.decoder_bias = nn.Parameter(torch.zeros(n_dim))
+
+    @classmethod
+    def from_pretrained(cls, ckpt_name='model_weights.pth', device='cuda', use_auth_token=None):
+        model = cls().to(device)
+
+        ckpt_path = ckpt_name
+        model.load_state_dict(torch.load(ckpt_path, map_location=device))
+        print(f"Model loaded successfully from {ckpt_path} to {device}")
+
+        return model
+
+    def forward(self, input_ids, masked_pos):
+        output = self.embedding(input_ids)
+        for layer in self.layers:
+            output, _ = layer(output)
+
+        masked_pos = masked_pos.long()[:, :, None].expand(-1, -1, output.size(-1))
+        h_masked = torch.gather(output, 1, masked_pos)
+        h_masked = self.norm(F.relu(self.linear(h_masked)))
+        logits_lm = self.decoder(h_masked) + self.decoder_bias
+
+        return logits_lm, output

utils.py

@@ -0,0 +1,323 @@
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from sklearn.manifold import TSNE
+import umap
+#%%
+def plot_dimensionality_reduction(tensor, method='all', labels=None, input_type='Unknown', task='Unknown'):
+    """
+    Plots 2D projections of high-dimensional data using PCA, t-SNE, or UMAP.
+    
+    Parameters:
+    tensor (torch.Tensor): Input data of shape (n_samples, n_features).
+    method (str or list): One of ['pca', 'tsne', 'umap'] or 'all' for all three.
+    labels (array-like): Optional labels for coloring the scatter plot.
+    input_type (str): Type of input data for title.
+    task (str): Task description for title.
+    """
+    tensor = tensor.view(tensor.size(0), -1)
+    # Convert to numpy if it's a PyTorch tensor
+    if isinstance(tensor, torch.Tensor):
+        tensor = tensor.cpu().numpy()
+    
+    methods = []
+    if method == 'all':
+        methods = ['pca', 'tsne', 'umap']
+    elif isinstance(method, str):
+        methods = [method]
+    elif isinstance(method, list):
+        methods = method
+    
+    plt.figure(figsize=(6 * len(methods), 5))
+    plt.suptitle(f"Input: {input_type}, Task: {task}", fontsize=16)
+    
+    for i, m in enumerate(methods):
+        if m == 'pca':
+            reducer = PCA(n_components=2)
+            title = 'PCA'
+        elif m == 'tsne':
+            reducer = TSNE(n_components=2, perplexity=2, random_state=42)
+            title = 't-SNE'
+        elif m == 'umap':
+            reducer = umap.UMAP(n_components=2, random_state=42)
+            title = 'UMAP'
+        else:
+            raise ValueError(f"Unknown method: {m}")
+        
+        reduced_data = reducer.fit_transform(tensor)
+        
+        plt.subplot(1, len(methods), i + 1)
+        
+        if labels is not None:
+            unique_labels = np.unique(labels)
+            cmap = plt.get_cmap('Spectral', len(unique_labels)) 
+            
+            scatter = plt.scatter(reduced_data[:, 0], reduced_data[:, 1], c=labels, cmap=cmap, alpha=0.75)
+            
+            cbar = plt.colorbar(scatter, ticks=unique_labels)
+            cbar.set_ticklabels(unique_labels)
+        else:
+            plt.scatter(reduced_data[:, 0], reduced_data[:, 1], alpha=0.75)
+        
+        plt.title(title, fontsize=14)
+        plt.xlabel("Component 1")
+        plt.ylabel("Component 2")
+        plt.grid(True, linestyle='--', alpha=0.5)
+    
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
+    plt.show()
+#%%
+def plot_coverage(receivers, coverage_map, dpi=200, figsize=(6, 4), cbar_title=None, title=None,
+                  scatter_size=12, transmitter_position=None, transmitter_orientation=None, 
+                  legend=False, limits=None, proj_3d=False, equal_aspect=False, tight_layout=True, 
+                  colormap='tab20'):
+    # Set up plot parameters
+    plot_params = {'cmap': colormap}
+    if limits:
+        plot_params['vmin'], plot_params['vmax'] = limits[0], limits[1]
+
+    # Extract coordinates
+    x, y = receivers[:, 0], receivers[:, 1]
+
+    # Create figure and axis
+    fig, ax = plt.subplots(dpi=dpi, figsize=figsize,
+                           subplot_kw={})
+    
+    # Plot the coverage map
+    ax.scatter(x, y, c=coverage_map, s=scatter_size, marker='s', edgecolors='black', linewidth=.15, **plot_params)
+    
+    # Set axis labels
+    ax.set_xlabel('x (m)')
+    ax.set_ylabel('y (m)')
+
+    # Add legend if requested
+    if legend:
+        ax.legend(loc='upper center', ncols=10, framealpha=0.5)
+
+    # Adjust plot limits
+    if tight_layout:
+        padding = 1
+        mins = np.min(receivers, axis=0) - padding
+        maxs = np.max(receivers, axis=0) + padding
+
+        ax.set_xlim([mins[0], maxs[0]])
+        ax.set_ylim([mins[1], maxs[1]])
+
+    # Set equal aspect ratio for 2D plots
+    if equal_aspect:
+        ax.set_aspect('equal')
+
+    # Show plot
+    plt.show()
+#%%
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, TensorDataset, random_split
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import f1_score
+
+# Data Preparation
+def get_data_loaders(data_tensor, labels_tensor, batch_size=32, split_ratio=0.8):
+    dataset = TensorDataset(data_tensor, labels_tensor)
+    
+    train_size = int(split_ratio * len(dataset))
+    test_size = len(dataset) - train_size
+    train_dataset, test_dataset = random_split(dataset, [train_size, test_size])
+
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
+    
+    return train_loader, test_loader
+
+class FCN(nn.Module):
+    def __init__(self, input_dim, num_classes):
+        super(FCN, self).__init__()
+        self.fc1 = nn.Linear(input_dim, 128)
+        self.bn1 = nn.BatchNorm1d(128)
+        self.dropout1 = nn.Dropout(0.3)
+        
+        self.fc2 = nn.Linear(128, 64)
+        self.bn2 = nn.BatchNorm1d(64)
+        self.dropout2 = nn.Dropout(0.3)
+        
+        self.fc3 = nn.Linear(64, num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.bn1(self.fc1(x)))
+        x = self.dropout1(x)
+        x = F.relu(self.bn2(self.fc2(x)))
+        x = self.dropout2(x)
+        return self.fc3(x)
+
+
+# Training Function
+def train_model(model, train_loader, test_loader, epochs=20, lr=0.001, device="cpu", decay_step=10, decay_rate=0.5):
+    model.to(device)
+    optimizer = optim.Adam(model.parameters(), lr=lr)
+    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=decay_step, gamma=decay_rate)
+    criterion = nn.CrossEntropyLoss()
+    
+    train_losses, test_f1_scores = [], []
+    
+    for epoch in range(epochs):
+        model.train()
+        epoch_loss = 0
+        for batch_x, batch_y in train_loader:
+            batch_x, batch_y = batch_x.to(device), batch_y.to(device)
+            
+            optimizer.zero_grad()
+            outputs = model(batch_x)
+            loss = criterion(outputs, batch_y)
+            loss.backward()
+            optimizer.step()
+            
+            epoch_loss += loss.item()
+        
+        train_losses.append(epoch_loss / len(train_loader))
+        scheduler.step()
+        
+        # Evaluate on test set
+        f1 = evaluate_model(model, test_loader, device)
+        test_f1_scores.append(f1)
+        
+        print(f"Epoch [{epoch+1}/{epochs}], Loss: {train_losses[-1]:.4f}, F1-score: {f1:.4f}, LR: {scheduler.get_last_lr()[0]:.6f}")
+    
+    return train_losses, np.array([test_f1_scores])
+
+# Model Evaluation
+def evaluate_model(model, test_loader, device):
+    model.eval()
+    all_preds, all_labels = [], []
+    
+    with torch.no_grad():
+        for batch_x, batch_y in test_loader:
+            batch_x, batch_y = batch_x.to(device), batch_y.to(device)
+            
+            outputs = model(batch_x)
+            preds = torch.argmax(outputs, dim=1)
+            
+            all_preds.extend(preds.cpu().numpy()) 
+            all_labels.extend(batch_y.cpu().numpy())
+
+    return f1_score(all_labels, all_preds, average='weighted')
+
+# Visualization
+import matplotlib.cm as cm
+def plot_metrics(test_f1_scores, input_types, n_train=None, flag=0):
+    """
+    Plots the F1-score over epochs or number of training samples.
+
+    Parameters:
+    test_f1_scores (list): List of F1-score values per epoch or training samples.
+    input_types (list): List of input type names.
+    n_train (list, optional): Number of training samples (used when flag=1).
+    flag (int): 0 for plotting F1-score over epochs, 1 for F1-score over training samples.
+    """
+    plt.figure(figsize=(7, 5), dpi=200)
+    colors = cm.get_cmap('Spectral', test_f1_scores.shape[0])  # Using Spectral colormap
+    markers = ['o', 's', 'D', '^', 'v', 'P', '*', 'X', 'h']  # Different markers for curves
+    
+    for r in range(test_f1_scores.shape[0]):
+        color = colors(r / (test_f1_scores.shape[0] - 1))  # Normalize color index
+        marker = markers[r % len(markers)]  # Cycle through markers
+        if flag == 0:
+            plt.plot(test_f1_scores[r], linewidth=2, marker=marker, markersize=5, markeredgewidth=1.5, 
+                     markeredgecolor=color, color=color, label=f"{input_types[r]}")
+        else:
+            plt.plot(n_train, test_f1_scores[r], linewidth=2, marker=marker, markersize=6, markeredgewidth=1.5, 
+                     markeredgecolor=color, markerfacecolor='none', color=color, label=f"{input_types[r]}")
+            plt.xscale('log') 
+    
+    x_label = "Epochs" if flag == 0 else "Number of training samples"
+    plt.xlabel(f"{x_label}", fontsize=12)
+    plt.ylabel("F1-score", fontsize=12)
+    
+    plt.legend()
+    plt.grid(alpha=0.3)
+    plt.show()
+
+#%%
+def classify_by_euclidean_distance(train_loader, test_loader, device="cpu"):
+    """
+    Classifies test samples based on the Euclidean distance to the mean of training samples from each class.
+    Computes the F1-score for evaluation.
+
+    Parameters:
+    - train_loader (DataLoader): DataLoader for training data.
+    - test_loader (DataLoader): DataLoader for test data.
+    - device (str): Device to run computations on ("cpu" or "cuda").
+
+    Returns:
+    - predictions (torch.Tensor): Predicted class for each test sample.
+    - f1 (float): Weighted F1-score.
+    """
+
+    # Store all training data and labels
+    train_data_list, train_labels_list = [], []
+    for batch_x, batch_y in train_loader:
+        train_data_list.append(batch_x.to(device))
+        train_labels_list.append(batch_y.to(device))
+    
+    train_data = torch.cat(train_data_list)
+    train_labels = torch.cat(train_labels_list)
+
+    unique_classes = torch.unique(train_labels)
+    class_means = {}
+
+    # Compute mean feature vector for each class
+    for cls in unique_classes:
+        class_means[cls.item()] = train_data[train_labels == cls].mean(dim=0)
+
+    # Convert class means to tensor for vectorized computation
+    class_means_tensor = torch.stack([class_means[cls.item()] for cls in unique_classes])
+
+    # Store all test data and labels
+    test_data_list, test_labels_list = [], []
+    for batch_x, batch_y in test_loader:
+        test_data_list.append(batch_x.to(device))
+        test_labels_list.append(batch_y.to(device))
+    
+    test_data = torch.cat(test_data_list)
+    test_labels = torch.cat(test_labels_list)
+
+    # Compute Euclidean distance between each test sample and all class means
+    dists = torch.cdist(test_data, class_means_tensor)  # Shape (n_test, n_classes)
+
+    # Assign the class with the minimum distance
+    predictions = unique_classes[torch.argmin(dists, dim=1)]
+
+    # Compute F1-score
+    f1 = f1_score(test_labels.cpu().numpy(), predictions.cpu().numpy(), average='weighted')
+
+    return f1
+#%%
+def generate_gaussian_noise(data, snr_db):
+    """
+    Generate complex-valued Gaussian noise given an SNR and apply it to the data.
+
+    Args:
+        data (np.ndarray): Input data array of shape (n_samples, n_features), assumed to be complex-valued.
+        snr_db (float): Signal-to-Noise Ratio in decibels (dB).
+
+    Returns:
+        np.ndarray: Complex-valued Gaussian noise of the same shape as data.
+    """
+    # Compute signal power
+    signal_power = np.mean(np.abs(data) ** 2, axis=1, keepdims=True)  # Shape: (n_samples, 1)
+
+    # Compute noise power from SNR
+    snr_linear = 10 ** (snr_db / 10)
+    noise_power = signal_power / snr_linear
+
+    # Generate complex Gaussian noise (real + imaginary parts)
+    noise_real = np.random.randn(*data.shape) * np.sqrt(noise_power / 2)
+    noise_imag = np.random.randn(*data.shape) * np.sqrt(noise_power / 2)
+
+    # Combine real and imaginary parts to form complex noise
+    noise = noise_real + 1j * noise_imag
+
+    return noise