|
|
|
"""
|
|
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 load_data import load_DeepMIMO_data
|
|
from input_preprocess import *
|
|
from lwm_model import LWM, load_model
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
from huggingface_hub import hf_hub_download
|
|
import torch
|
|
|
|
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):
|
|
|
|
model = cls().to(device)
|
|
|
|
|
|
ckpt_path = hf_hub_download(repo_id="sadjadalikhani/LWM", filename=ckpt_name, use_auth_token=use_auth_token)
|
|
|
|
|
|
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
|
|
|
