upload required files

input_preprocess.py

@@ -0,0 +1,348 @@
+# -*- 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 dataset_gen
+import dataset_utils as dt
+import os
+from tqdm import tqdm
+import time
+import pickle
+import DeepMIMOv3
+
+vars_folder = 'variables/'
+os.makedirs(vars_folder, exist_ok=True)
+
+#%% 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 gen_tokens(scenario_idxs, patch_gen=True, patch_size=16, 
+               gen_deepMIMO_data=False, gen_raw=False, save_data=False):
+    """
+    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.
+    """
+
+    vars_folder = 'variables/'
+    os.makedirs(vars_folder, exist_ok=True)
+    
+    # Fetch scenarios
+    scenario_list = scenarios_list()
+    scenarios = scenario_list[scenario_idxs] if len(scenario_idxs) > 1 else [scenario_list[scenario_idxs[0]]]
+    
+    # Patch generation or loading
+    if patch_gen:
+        patches = [patch_makerv2(patch_size=patch_size, scenario=scenario, 
+                                 gen_deepMIMO_data=gen_deepMIMO_data, save_patches=False,
+                                 save_file_name=f'patch_{scenario}.p', 
+                                 norm_factor=1e6, save_data=save_data) 
+                   for scenario in scenarios]
+        patches = np.vstack(patches)
+    else:
+        patches = [dt.load_var(vars_folder + 'patch_{scenario}.p') 
+                   for scenario in scenarios]
+        patches = np.vstack(patches)
+    
+    word2id = {'[CLS]': 0.2 * np.ones((patch_size)), '[MASK]': 0.1 * np.ones((patch_size))}
+    
+    # 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
+
+    # Generate preprocessed data
+    preprocessed_data = []
+    for user_idx in tqdm(range(len(patches)), desc="Processing items"):
+        sample = make_samplev2(user_idx, patches, word2id, n_patches, n_masks_half, patch_size, gen_raw=gen_raw)
+        preprocessed_data.append(sample)
+
+    if save_data:
+        dt.save_var(preprocessed_data, vars_folder + 'preprocessed_data.p')
+            
+    return preprocessed_data, sequence_length, element_length
+
+
+#%% Patch Creation
+def patch_makerv2(patch_size=16, scenario=None, gen_deepMIMO_data=False, 
+                  save_patches=True, save_file_name=None, norm_factor=1, 
+                  save_data=False):
+    """
+    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.
+        save_patches (bool): Whether to save generated patches.
+        save_file_name (str): Filename for saving patches.
+        norm_factor (int): Normalization factor for channels.
+        save_data (bool): Whether to save data.
+
+    Returns:
+        patch (numpy array): Generated patches.
+    """
+
+    vars_folder = 'variables/'
+    os.makedirs(vars_folder, exist_ok=True)
+    
+    data = DeepMIMO_data_gen(scenario, gen_deepMIMO_data, save_data=save_data)
+    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)) * norm_factor
+    
+    # Create patches
+    n_patches = flat_channels_complex.shape[1] // patch_size
+    patch = np.zeros((len(idxs), n_patches, patch_size))
+    for idx in range(n_patches):
+        patch[:, idx, :] = flat_channels_complex[:, idx * patch_size:(idx + 1) * patch_size]
+    
+    if save_patches:
+        dt.save_var(patch, vars_folder + save_file_name)
+    
+    return patch
+
+
+#%% Data Generation for Scenario Areas
+def DeepMIMO_data_gen(scenario, gen_deepMIMO_data, save_data=False):
+    """
+    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.
+    """
+    
+    parameters, row_column_users, n_ant_bs, n_ant_ue, n_subcarriers = get_parameters(scenario)
+    
+    if gen_deepMIMO_data:
+        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]
+        
+        if save_data:
+            save_var(data, vars_folder + f'data_{scenario}_{n_ant_bs}_{n_ant_ue}_{n_subcarriers}.p')    
+    else:
+        data = load_var(vars_folder + f'data_{scenario}_{n_ant_bs}_{n_ant_ue}_{n_subcarriers}.p')
+    
+    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_samplev2(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
+
+#%%
+scenario_idxs = [0, 1, 2, 3, 4, 5]
+
+preprocessed_data, max_len, element_length = gen_tokens(scenario_idxs, 
+                                                        patch_gen=True, 
+                                                        patch_size=16, 
+                                                        gen_deepMIMO_data=True, 
+                                                        gen_raw=True, 
+                                                        save_data=False)
+
+#%%

lwm_model.py

@@ -0,0 +1,173 @@
+"""
+LWM (Large Wireless Model) Implementation and Loading
+
+@author: salikha4
+
+This module defines a Large Wireless Model (LWM) using PyTorch, including custom layers
+for embedding, self-attention, and feed-forward networks. It also provides functionality
+to load a pre-trained model from a checkpoint.
+
+Dependencies:
+    - torch
+    - numpy
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+# Constants
+ELEMENT_LENGTH = 16
+MAX_LEN = 129
+N_LAYERS = 12
+N_HEADS = 12
+D_MODEL = 64
+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 #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) #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(nn.Module):
+    def __init__(self, element_length, d_model, max_len, n_layers):
+        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.weight = nn.Parameter(embed_weight.transpose(0, 1))
+        self.decoder_bias = nn.Parameter(torch.zeros(n_dim))
+
+    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
+
+def load_model(model, model_path, device=None):
+    """
+    Load a pre-trained LWM model from a checkpoint.
+
+    Args:
+        model_path (str): Path to the checkpoint file.
+        device (torch.device, optional): Device to load the model onto.
+
+    Returns:
+        LWM: Loaded model instance.
+    """
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    #model = LWM(ELEMENT_LENGTH, D_MODEL, MAX_LEN, N_LAYERS)
+    state_dict = torch.load(model_path, map_location=device)
+    model.load_state_dict(state_dict)
+    model.to(device)
+    return model
+
+# Usage example
+if __name__ == "__main__":
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model_name = 'model_weights.pth'
+    model_path = f'huggingFace/{model_name}'
+
+    model = LWM(ELEMENT_LENGTH, D_MODEL, MAX_LEN, N_LAYERS)
+    
+    model = load_model(model, model_path, device)
+    print(f"Model loaded successfully on {device}")
+    print(f"Model parameters: {sum(p.numel() for p in model.parameters())}")

model.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Sep 13 19:16:12 2024
+
+@author: salikha4
+"""
+
+from transformers import PreTrainedModel, PretrainedConfig
+from lwm_model import LWM  
+
+class WirelessConfig(PretrainedConfig):
+    model_type = "lwm"
+    
+    def __init__(self, element_length=16, d_model=64, max_len=129, n_layers=12, **kwargs):
+        super().__init__(**kwargs)
+        self.element_length = element_length
+        self.d_model = d_model
+        self.max_len = max_len
+        self.n_layers = n_layers
+
+class WirelessChannelModel(PreTrainedModel):
+    config_class = WirelessConfig
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.lwm = LWM(config.element_length, config.d_model, config.max_len, config.n_layers)
+
+    def forward(self, input_ids, masked_pos):
+        return self.lwm(input_ids, masked_pos)

model_weights.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:838d9f35e9e1bfd46e4c3212d00fa069f5ea02a93c0f807d25399e755b2eebbc
+size 2509918

save_model.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Sep 13 19:16:37 2024
+
+@author: salikha4
+"""
+
+import torch
+from tokenizer import WirelessChannelTokenizer
+from model import WirelessChannelModel, WirelessConfig
+
+model_name = 'model_weights.pth'
+model_path = f'huggingFace/{model_name}'
+
+# Initialize model config
+config = WirelessConfig()
+
+# Initialize the model
+model = WirelessChannelModel(config)
+
+# Load pretrained weights
+model.load_state_dict(torch.load(model_path))
+
+# Initialize tokenizer (preprocessor)
+tokenizer = WirelessChannelTokenizer(patch_size=16, max_len=129)
+
+# Save the model and tokenizer for Hugging Face
+model.save_pretrained("huggingFace/")
+tokenizer.save_pretrained("huggingFace/")

tokenizer.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Sep 13 19:15:23 2024
+
+@author: salikha4
+"""
+
+from transformers import PreTrainedTokenizer
+from input_preprocess import gen_tokens
+
+class WirelessChannelTokenizer(PreTrainedTokenizer):
+    """
+    A Hugging Face-compatible tokenizer for wireless channels. 
+    It performs segmentation and masking for wireless channel data.
+    """
+    def __init__(self, patch_size=16, max_len=129, **kwargs):
+        super().__init__(**kwargs)
+        self.patch_size = patch_size
+        self.max_len = max_len
+
+    def preprocess_channels(self, scenario_idxs):
+        # Call gen_tokens() for preprocessing the wireless channel data
+        preprocessed_data, sequence_length, element_length = gen_tokens(
+            scenario_idxs, patch_gen=True, patch_size=self.patch_size,
+            gen_deepMIMO_data=True, gen_raw=True, save_data=False
+        )
+        return preprocessed_data
+
+    def __call__(self, scenario_idxs):
+        return self.preprocess_channels(scenario_idxs)
+
+    def save_pretrained(self, save_directory):
+        super().save_pretrained(save_directory)

upload_to_huggingface.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Sep 13 19:31:13 2024
+
+@author: salikha4
+"""
+
+from huggingface_hub import HfApi
+
+api = HfApi()
+
+# Upload the folder containing both model and tokenizer
+api.upload_folder(
+    folder_path="path_to_save_model",  # The folder containing saved model/tokenizer
+    repo_id="your_username/your_model_name",  # Your Hugging Face username and model name
+    private=True  # Set to True for private, False for public
+)