Fix: Upload full SignVLM architecture to model.py

model.py

@@ -1,4 +1,58 @@
 
 import torch
 import torch.nn as nn
-# ... Paste your full model class code here ...
+import torch.nn.functional as F
+
+class PositionalEmbedding(nn.Module):
+    def __init__(self, sequence_length, embed_dim):
+        super().__init__()
+        self.pos_emb = nn.Embedding(sequence_length, embed_dim)
+
+    def forward(self, x):
+        positions = torch.arange(0, x.size(1), device=x.device).unsqueeze(0)
+        return x + self.pos_emb(positions)
+
+class TransformerBlock(nn.Module):
+    def __init__(self, embed_dim, num_heads, ff_dim, dropout=0.1):
+        super().__init__()
+        self.att = nn.MultiheadAttention(embed_dim, num_heads, dropout=dropout, batch_first=True)
+        self.ffn = nn.Sequential(
+            nn.Linear(embed_dim, ff_dim),
+            nn.ReLU(),
+            nn.Linear(ff_dim, embed_dim)
+        )
+        self.layernorm1 = nn.LayerNormalization(embed_dim)
+        self.layernorm2 = nn.LayerNormalization(embed_dim)
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x):
+        attn_output, _ = self.att(x, x, x)
+        x = self.layernorm1(x + self.dropout(attn_output))
+        ffn_output = self.ffn(x)
+        x = self.layernorm2(x + self.dropout(ffn_output))
+        return x
+
+class SignVLM(nn.Module):
+    def __init__(self, input_shape=(64, 225), num_classes=60, embed_dim=256, num_heads=8, ff_dim=512):
+        super().__init__()
+        self.dense_proj = nn.Linear(input_shape[1], embed_dim)
+        self.pos_emb = PositionalEmbedding(input_shape[0], embed_dim)
+        
+        self.transformer_blocks = nn.ModuleList([
+            TransformerBlock(embed_dim, num_heads, ff_dim) for _ in range(4)
+        ])
+        
+        self.dropout = nn.Dropout(0.5)
+        self.classifier = nn.Linear(embed_dim, num_classes)
+
+    def forward(self, x):
+        # x shape: (batch, 64, 225)
+        x = self.dense_proj(x)
+        x = self.pos_emb(x)
+        
+        for block in self.transformer_blocks:
+            x = block(x)
+            
+        x = x.mean(dim=1) # Global Average Pooling
+        x = self.dropout(x)
+        return self.classifier(x)