Upload model.py with huggingface_hub

model.py

@@ -0,0 +1,166 @@
+import math
+import torch
+import torch.nn as nn
+from transformers import BertConfig
+from torch.utils.checkpoint import checkpoint
+
+class ConvBlock(nn.Module):
+    def __init__(self, hidden_size, kernel_size=3, padding=1):
+        super().__init__()
+        self.conv_dw = nn.Conv1d(
+            in_channels=hidden_size,
+            out_channels=hidden_size,
+            kernel_size=kernel_size,
+            padding=padding,
+            groups=hidden_size
+        )
+        self.conv_pw = nn.Conv1d(
+            in_channels=hidden_size,
+            out_channels=hidden_size,
+            kernel_size=1
+        )
+        self.norm1 = nn.LayerNorm(hidden_size)
+        self.ffn = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size * 4),
+            nn.GELU(),
+            nn.Linear(hidden_size * 4, hidden_size)
+        )
+        self.norm2 = nn.LayerNorm(hidden_size)
+        self.dropout = nn.Dropout(0.1)
+
+    def forward(self, x):
+        residual = x
+        x_conv = x.transpose(1, 2)
+        x_conv = self.conv_dw(x_conv)
+        x_conv = self.conv_pw(x_conv)
+        x_conv = x_conv.transpose(1, 2)
+        x = self.norm1(residual + self.dropout(x_conv))
+        residual = x
+        x_ffn = self.ffn(x)
+        x = self.norm2(residual + self.dropout(x_ffn))
+        return x
+
+
+class AttentionBlock(nn.Module):
+    def __init__(self, hidden_size, num_heads):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(
+            embed_dim=hidden_size,
+            num_heads=num_heads,
+            dropout=0.1,
+            batch_first=True
+        )
+        self.norm1 = nn.LayerNorm(hidden_size)
+        self.ffn = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size * 4),
+            nn.GELU(),
+            nn.Linear(hidden_size * 4, hidden_size)
+        )
+        self.norm2 = nn.LayerNorm(hidden_size)
+        self.dropout = nn.Dropout(0.1)
+
+    def forward(self, x, attention_mask=None):
+        residual = x
+        if attention_mask is not None:
+            key_padding_mask = (attention_mask == 0)
+        else:
+            key_padding_mask = None
+            
+        attn_output, _ = self.self_attn(
+            query=x,
+            key=x,
+            value=x,
+            key_padding_mask=key_padding_mask,
+            need_weights=False
+        )
+        x = self.norm1(residual + self.dropout(attn_output))
+        residual = x
+        x_ffn = self.ffn(x)
+        x = self.norm2(residual + self.dropout(x_ffn))
+        return x
+
+
+class HCAEModel(nn.Module):
+    def __init__(self, vocab_size=30522, hidden_size=384, max_seq_len=512, 
+                 conv_layers=5, attn_layers=3, num_heads=12):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.word_embeddings = nn.Embedding(vocab_size, hidden_size, padding_idx=0)
+        self.position_embeddings = nn.Embedding(max_seq_len, hidden_size)
+        self.LayerNorm = nn.LayerNorm(hidden_size)
+        self.dropout = nn.Dropout(0.1)
+        self.conv_blocks = nn.ModuleList([
+            ConvBlock(hidden_size) for _ in range(conv_layers)
+        ])
+        self.attn_blocks = nn.ModuleList([
+            AttentionBlock(hidden_size, num_heads) for _ in range(attn_layers)
+        ])
+        self.use_gradient_checkpointing = False
+
+    def forward(self, input_ids, attention_mask=None):
+        seq_length = input_ids.size(1)
+        position_ids = torch.arange(seq_length, dtype=torch.long, device=input_ids.device)
+        position_ids = position_ids.unsqueeze(0).expand_as(input_ids)
+        
+        words_embeddings = self.word_embeddings(input_ids)
+        position_embeddings = self.position_embeddings(position_ids)
+        x = words_embeddings + position_embeddings
+        x = self.LayerNorm(x)
+        x = self.dropout(x)
+        
+        for i, block in enumerate(self.conv_blocks):
+            if self.use_gradient_checkpointing and self.training:
+                def create_custom_forward(module):
+                    def custom_forward(*args):
+                        return module(*args)
+                    return custom_forward
+                x = checkpoint(create_custom_forward(block), x, use_reentrant=False)
+            else:
+                x = block(x)
+                
+        for i, block in enumerate(self.attn_blocks):
+            if self.use_gradient_checkpointing and self.training:
+                def create_custom_forward(module):
+                    def custom_forward(hidden_states, mask):
+                        return module(hidden_states, attention_mask=mask)
+                    return custom_forward
+                x = checkpoint(create_custom_forward(block), x, attention_mask, use_reentrant=False)
+            else:
+                x = block(x, attention_mask=attention_mask)
+        
+        if attention_mask is not None:
+            input_mask_expanded = attention_mask.unsqueeze(-1).expand(x.size()).float()
+            sum_embeddings = torch.sum(x * input_mask_expanded, 1)
+            sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+            sentence_embeddings = sum_embeddings / sum_mask
+        else:
+            sentence_embeddings = x.mean(dim=1)
+            
+        return sentence_embeddings
+
+if __name__ == "__main__":
+    model = HCAEModel()
+    total_params = sum(p.numel() for p in model.parameters())
+    print(f"Total parameters: {total_params / 1e6:.2f} M")
+    
+    batch_size = 32
+    seq_len = 128
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model.to(device)
+    
+    dummy_input = torch.randint(0, 30522, (batch_size, seq_len)).to(device)
+    dummy_mask = torch.ones((batch_size, seq_len)).to(device)
+    
+    model.use_gradient_checkpointing = True
+    
+    with torch.cuda.amp.autocast(dtype=torch.float16):
+        output = model(dummy_input, attention_mask=dummy_mask)
+        
+    print(f"Output shape: {output.shape}")
+    
+    if torch.cuda.is_available():
+        memory_allocated = torch.cuda.memory_allocated(device) / (1024 ** 2)
+        memory_reserved = torch.cuda.memory_reserved(device) / (1024 ** 2)
+        print(f"CUDA memory allocated: {memory_allocated:.2f} MB")
+        print(f"CUDA memory reserved: {memory_reserved:.2f} MB")