Update config.py

config.py

@@ -0,0 +1,67 @@
+from transformers import PreTrainedConfig
+
+class NULAConfig(PreTrainedConfig):
+    model_type="nula"
+    def __init__(
+        self, num_classes=10, in_channels=3, input_size=(3, 32, 32), block_channels=(128, 256, 512), 
+        use_residual=True, use_se=True, use_spatial_attention=False, se_reduction=16, classifier_hidden_dim=256,
+        mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), id2label=None, label2id=None, **kwargs
+    ):
+        super().__init__(**kwargs)
+
+        self.num_classes = num_classes
+        self.in_channels = in_channels
+        self.input_size = input_size
+        self.block_channels = list(block_channels)
+        
+        self.use_residual = use_residual
+        self.use_se = use_se
+        self.use_spatial_attention = use_spatial_attention
+        self.se_reduction = se_reduction
+        
+        self.classifier_hidden_dim = classifier_hidden_dim
+        self.mean = list(mean)
+        self.std = list(std)
+
+        if id2label is None or label2id is None:
+            labels = [
+                "airplane", "automobile", "bird", "cat", "deer",
+                "dog", "frog", "horse", "ship", "truck"
+            ]
+            self.id2label = {i: label for i, label in enumerate(labels)}
+            self.label2id = {label: i for i, label in enumerate(labels)}
+        else:
+            self.id2label = id2label
+            self.label2id = label2id 
+            
+        self._val_invars()
+
+    def _val_invars(self):
+        if self.num_classes <= 0:
+            raise ValueError(f"num_classes must be positive, got {self.num_classes}")
+        if self.classifier_hidden_dim <= 0:
+            raise ValueError(
+                f"classifier_hidden_dim must be positive, got {self.classifier_hidden_dim}"
+            )
+        if len(self.input_size) != 3:
+            raise ValueError(f"input_size must be (C, H, W), got {self.input_size}")
+
+        C, H, W = self.input_size
+        if C != self.in_channels:
+            raise ValueError(f"channel mismatch: input_size[0]={C}, in_channels={self.in_channels}")
+        if H <= 0 or W <= 0:
+            raise ValueError(f"spatial dimensions must be positive, got H={H}, W={W}")
+            
+        if len(self.block_channels) == 0:
+            raise ValueError("the model needs at least one layer!")
+        if any(c <= 0 for c in self.block_channels):
+            raise ValueError(f"invalid block_channels: {self.block_channels}")
+        if self.use_se and self.se_reduction <= 0:
+            raise ValueError(f"se_reduction must be positive, got {self.se_reduction}")
+        if len(self.mean) != self.in_channels or len(self.std) != self.in_channels:
+            raise ValueError("mean/std length must match in_channels")
+            
+        if self.num_classes != len(self.id2label):
+            raise ValueError(f"num_classes ({self.num_classes}) != label count ({len(self.id2label)})")
+        if set(self.label2id.values()) != set(range(self.num_classes)):
+            raise ValueError("label2id values must cover [0, ..., num_classes-1]")