Upload 3 files

inference.py

@@ -23,7 +23,6 @@ import numpy as np
 #from lwm_model import LWM, load_model
 import warnings
 warnings.filterwarnings('ignore')
-from input_preprocess import *
 
 # Device configuration
 device = torch.device('cuda' if torch.cuda.is_available() else "cpu")
@@ -68,90 +67,3 @@ def create_raw_dataset(data, device):
     input_data = torch.tensor(input_ids, device=device)[:, 1:]
     return input_data.float()
 
-
-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):
-    # phi = azimuth
-    # theta = elevation
-    idxs = DeepMIMOv3.ant_indices(array)
-    resp = DeepMIMOv3.array_response(idxs, phi, theta+np.pi/2, kd)
-    return resp / np.linalg.norm(resp)
-
-
-def evaluate(model, dataloader):
-
-    model.eval()
-    running_loss = 0.0
-    outputs = []
-    criterionMCM = nn.MSELoss()
-    
-    with torch.no_grad():
-        for batch in 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 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

input_preprocess.py

@@ -59,8 +59,8 @@ def tokenizer(selected_scenario_names=None, manual_data=None, gen_raw=True):
     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
+    # sequence_length = n_patches + 1
+    # element_length = patch_size
     
     word2id = {'[CLS]': 0.2 * np.ones((patch_size)), '[MASK]': 0.1 * np.ones((patch_size))}
 
@@ -307,4 +307,90 @@ def load_var(path):
     
     return var
 
-#%%
+#%%
+
+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):
+    # phi = azimuth
+    # theta = elevation
+    idxs = DeepMIMOv3.ant_indices(array)
+    resp = DeepMIMOv3.array_response(idxs, phi, theta+np.pi/2, kd)
+    return resp / np.linalg.norm(resp)
+
+
+def evaluate(model, dataloader):
+
+    model.eval()
+    running_loss = 0.0
+    outputs = []
+    criterionMCM = nn.MSELoss()
+    
+    with torch.no_grad():
+        for batch in 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 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

lwm_model.py

@@ -1,151 +1,153 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Sun Sep 15 19:55:23 2024
-
-@author: salikha4
-"""
-
-import os
-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 #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(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.weight = nn.Parameter(embed_weight.transpose(0, 1))
-        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):
-        # Define model
-        model = cls().to(device)
-
-        # Download model weights using Hugging Face Hub
-        # ckpt_path = hf_hub_download(repo_id="sadjadalikhani/LWM", filename=ckpt_name, use_auth_token=use_auth_token)
-        ckpt_path = ckpt_name
-        
-        # Load the model weights
-        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):
-        # Forward pass
-        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
-
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Sep 15 19:55:23 2024
+
+@author: salikha4
+"""
+
+# import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+# from inference import *
+# from input_preprocess import *
+
+
+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 #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(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.weight = nn.Parameter(embed_weight.transpose(0, 1))
+        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):
+        # Define model
+        model = cls().to(device)
+
+        # Download model weights using Hugging Face Hub
+        # ckpt_path = hf_hub_download(repo_id="sadjadalikhani/LWM", filename=ckpt_name, use_auth_token=use_auth_token)
+        ckpt_path = ckpt_name
+        
+        # Load the model weights
+        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):
+        # Forward pass
+        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
+