Upload 2 files

model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0740d68419d8bcf879803726364ac1a49b7c42fa6db171444828f85a74dd98ab
+size 1837731

model.py

@@ -0,0 +1,127 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class InputPreparer(nn.Module):
+    def __init__(self):
+        super().__init__()
+        # smoothing and diff filters
+        matrix_a = torch.tensor([[1., 2., 1.],
+                                 [2., 4., 2.],
+                                 [1., 2., 1.]], dtype=torch.float32) / 16.0
+        self.register_buffer('filter_pattern_a', matrix_a.view(1, 1, 3, 3))
+
+        matrix_b = torch.tensor([[-1., 0., 1.],[-2., 0., 2.],[-1., 0., 1.]], dtype=torch.float32).view(1, 1, 3, 3)
+        matrix_c = torch.tensor([[-1., -2., -1.],
+                                 [ 0.,  0.,  0.],
+                                 [ 1.,  2.,  1.]], dtype=torch.float32).view(1, 1, 3, 3)
+        self.register_buffer('filter_pattern_b', matrix_b)
+        self.register_buffer('filter_pattern_c',matrix_c)
+
+        self.gating_network = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            nn.Conv2d(2,2, kernel_size=1),
+            nn.Sigmoid()
+        )
+        self.mapping_conv = nn.Conv2d(2, 32, kernel_size=3, padding=1, bias=False)
+        self.normalization = nn.BatchNorm2d(32)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        filtered_input = F.conv2d(x, self.filter_pattern_a, padding=1)
+        response_b = F.conv2d(filtered_input, self.filter_pattern_b, padding=1)
+        response_c = F.conv2d(filtered_input, self.filter_pattern_c, padding=1)
+        combined_response = torch.sqrt(response_b**2 + response_c**2+1e-5)
+        
+        integrated_features = torch.cat([x, combined_response], dim=1)
+        modulated_features = integrated_features * self.gating_network(integrated_features)
+        return F.silu(self.normalization(self.mapping_conv(modulated_features)))
+
+
+class MagnitudeScaler(nn.Module):
+    def __init__(self, kernel_size=2, stride=2, padding=0):
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.padding = padding
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        squared_values = torch.clamp(x, min=0.0)**2
+        aggregated_values = F.avg_pool2d(squared_values, self.kernel_size, self.stride, self.padding)
+        return torch.sqrt(aggregated_values + 1e-5)
+
+
+class FeatureWeighting(nn.Module):
+    def __init__(self, kernel_size: int = 7):
+        super().__init__()
+        self.spatial_weighting = nn.Conv2d(2, 1, kernel_size=kernel_size, padding=kernel_size // 2, bias=False)
+        self.activation = nn.Sigmoid()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        mean_projection = torch.mean(x, dim=1, keepdim=True)
+        max_projection, _ = torch.max(x, dim=1, keepdim=True)
+        combined_projection = torch.cat([mean_projection, max_projection], dim=1)
+        return x * self.activation(self.spatial_weighting(combined_projection))
+
+
+class ProcessingBlock(nn.Module):
+    def __init__(self, in_c: int, out_c: int, drop: float = 0.1) -> None:
+        super().__init__()
+        self.core_conv = nn.Conv2d(in_c, out_c, kernel_size=3, padding=1, bias=False)
+        self.core_norm = nn.BatchNorm2d(out_c)
+        self.refinement = FeatureWeighting()
+        self.nonlinearity = nn.SiLU()  
+        self.regularization = nn.Dropout2d(p=drop)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        out = self.nonlinearity(self.core_norm(self.core_conv(x)))
+        out = self.regularization(out)
+        return self.refinement(out)
+
+
+class HierarchicalNetwork(nn.Module):
+    def __init__(self, out_dims: int = 11):
+        super().__init__()
+        self.pre_processor = InputPreparer()
+        
+        self.stage_a = ProcessingBlock(32, 64, drop=0.1)
+        self.downsampler_a = MagnitudeScaler(kernel_size=2, stride=2)
+        
+        self.stage_b = ProcessingBlock(64, 128, drop=0.1)
+        self.downsampler_b = MagnitudeScaler(kernel_size=2, stride=2)
+        
+        self.stage_c = ProcessingBlock(128, 256, drop=0.1)
+        self.global_reducer_a = nn.AdaptiveAvgPool2d(1)
+        self.global_reducer_b = nn.AdaptiveMaxPool2d(1)
+        
+        self.decision_network = nn.Sequential(
+            nn.Linear(256 * 2, 128),
+            nn.SiLU(),
+            nn.Dropout(0.2),
+            nn.Linear(128, out_dims)
+        )
+        self._reset_parameters()
+
+
+    def _reset_parameters(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.ones_(m.weight)
+                nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.zeros_(m.bias)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.pre_processor(x)
+        x = self.downsampler_a(self.stage_a(x))
+        x = self.downsampler_b(self.stage_b(x))
+        x = self.stage_c(x)
+        
+        reduced_a = self.global_reducer_a(x).view(x.size(0), -1)
+        reduced_b = self.global_reducer_b(x).view(x.size(0), -1)
+        
+        return self.decision_network(torch.cat([reduced_a, reduced_b], dim=1))