Keep per-layer metadata valid when scaling child models

create_child_job.py

@@ -112,8 +112,21 @@ def best_head_count(hidden_size: int, original: int) -> int:
     return min(choices or [1], key=lambda value: abs(value - target))
 
 
+def resize_layer_sequence(values: list[Any], new_length: int) -> list[Any]:
+    """Resize per-layer metadata while preserving its distribution and final layer."""
+    if new_length <= 0 or not values:
+        return []
+    if len(values) == new_length:
+        return list(values)
+    if new_length == 1:
+        return [values[-1]]
+    last = len(values) - 1
+    indices = [round(index * last / (new_length - 1)) for index in range(new_length)]
+    return [values[index] for index in indices]
+
+
 def scale_config_object(config: Any, ratio: float, overrides: dict[str, Any] | None = None) -> dict[str, Any]:
-    """Scale common Transformer dimensions in-place while preserving tokenizer/task heads."""
+    """Scale common Transformer dimensions and keep architecture-coupled fields valid."""
     overrides = overrides or {}
     layer_scale = max(0.18, min(1.0, ratio ** 0.40))
     hidden_scale = max(0.22, min(1.0, ratio ** 0.30))
@@ -122,17 +135,42 @@ def scale_config_object(config: Any, ratio: float, overrides: dict[str, Any] | N
     hidden_keys = ["hidden_size", "d_model", "n_embd", "model_dim"]
     ff_keys = ["intermediate_size", "d_ff", "ffn_dim", "encoder_ffn_dim", "decoder_ffn_dim"]
     head_keys = ["num_attention_heads", "n_head", "encoder_attention_heads", "decoder_attention_heads"]
-
+    per_layer_keys = ["layer_types", "mlp_layer_types", "block_types", "attention_types"]
+
+    original_layer_count = getattr(config, "num_hidden_layers", None)
+    per_layer_values = {
+        key: list(value)
+        for key in per_layer_keys
+        if isinstance((value := getattr(config, key, None)), (list, tuple))
+    }
     original_heads: dict[str, int] = {}
     for key in head_keys:
         value = getattr(config, key, None)
         if isinstance(value, int) and value > 0:
             original_heads[key] = value
 
+    scaled_layer_counts: dict[str, int] = {}
     for key in layer_keys:
         value = getattr(config, key, None)
         if isinstance(value, int) and value > 1:
-            setattr(config, key, max(2, int(round(value * layer_scale))))
+            scaled_layer_counts[key] = max(2, int(round(value * layer_scale)))
+    for key, value in scaled_layer_counts.items():
+        setattr(config, key, value)
+
+    new_layer_count = getattr(config, "num_hidden_layers", None)
+    if isinstance(new_layer_count, int) and new_layer_count > 0:
+        for key, values in per_layer_values.items():
+            setattr(config, key, resize_layer_sequence(values, new_layer_count))
+        max_window_layers = getattr(config, "max_window_layers", None)
+        if isinstance(max_window_layers, int):
+            setattr(config, "max_window_layers", min(max_window_layers, new_layer_count))
+        # Some hybrid architectures keep additional lists not known in advance.
+        if isinstance(original_layer_count, int) and original_layer_count > 0:
+            for key, value in list(getattr(config, "__dict__", {}).items()):
+                if key in per_layer_keys:
+                    continue
+                if isinstance(value, list) and len(value) == original_layer_count and ("layer" in key or "block" in key or "attention" in key):
+                    setattr(config, key, resize_layer_sequence(value, new_layer_count))
 
     hidden_value = None
     for key in hidden_keys:
@@ -169,6 +207,10 @@ def scale_config_object(config: Any, ratio: float, overrides: dict[str, Any] | N
         if hasattr(config, key):
             setattr(config, key, value)
 
+    # Re-run generic validators before publishing instead of discovering errors at load time.
+    validator = getattr(config, "validate_layer_type", None)
+    if callable(validator):
+        validator()
     return config.to_dict() if hasattr(config, "to_dict") else {}