Delete lwm_model.py

lwm_model.py

@@ -1,173 +0,0 @@
-"""
-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
-
-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(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))
-
-    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'models/{model_name}'
-
-    model = LWM()
-    
-    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())}")