feat(model/gemma4): neutral vision config inference from weight shapes (vision loader 2/n)

Completes the neutral front of the gemma4 vision loader (#8): gemma4VisionShouldBuildEncoderTower (the
unified text/vision variants declare no encoder) + inferGemma4VisionConfig (hidden_size + patch_size from
the patch-embedding shape, head_dim from hidden/heads, the layer count by walking encoder.layers.N) — the
vision-side parallel of the text infer.go, reusing model.WeightAny. Read from the tensors, never guessed.
The device build of the SigLIP tower from these weights (native structs + weight upload) is next, in pkg/native.

pkg/model green.

Co-Authored-By: Virgil <virgil@lethean.io>

Author: Snider

go/pkg/model/gemma4/vision_infer.go

@@ -0,0 +1,90 @@
+// SPDX-Licence-Identifier: EUPL-1.2
+
+package gemma4
+
+import (
+	"math"
+
+	core "dappco.re/go"
+	"dappco.re/go/mlx/pkg/model"
+	"dappco.re/go/mlx/pkg/safetensors"
+)
+
+// vision_infer.go completes the neutral vision-loader front: decide whether a pack carries a SigLIP
+// encoder tower (vs the unified text-only / projector-only variants) and infer the vision config's
+// per-model dims from the weight SHAPES (the don't-guess rule) — the vision-side parallel of infer.go.
+// Lifted from pkg/metal/model/gemma4/vision_load.go; the device build of the tower from these weights is
+// backend-side (pkg/native), the same split as the text path.
+
+// gemma4VisionShouldBuildEncoderTower reports whether a pack carries a full SigLIP encoder tower. The
+// unified text / unified-vision variants declare no encoder.
+func gemma4VisionShouldBuildEncoderTower(cfg *Gemma4TextConfig) bool {
+	if cfg == nil {
+		return true
+	}
+	if cfg.ModelType == "gemma4_unified" || cfg.ModelType == "gemma4_unified_text" {
+		return false
+	}
+	if cfg.VisionConfig != nil && cfg.VisionConfig.ModelType == "gemma4_unified_vision" {
+		return false
+	}
+	return true
+}
+
+// inferGemma4VisionConfig fills the vision config's per-model dims from the weight shapes: hidden_size +
+// patch_size from the patch-embedding weight, head_dim from hidden/heads, kv-heads default, and the layer
+// count by walking encoder.layers.N until a q_proj is absent. Read from the tensors, never guessed.
+func inferGemma4VisionConfig(weights map[string]safetensors.Tensor, cfg *Gemma4VisionConfig) *Gemma4VisionConfig {
+	if cfg == nil {
+		cfg = &Gemma4VisionConfig{}
+	}
+	if w, ok := model.WeightAny(weights,
+		"patch_embedder.input_proj.weight",
+		"patch_embedder.input_proj.linear.weight",
+		"embeddings.patch_embedding.weight",
+		"patch_embedding.weight",
+	); ok {
+		shape := w.Shape
+		if len(shape) > 0 && shape[0] > 0 {
+			cfg.HiddenSize = int32(shape[0])
+		}
+		patchDim := 0
+		switch len(shape) {
+		case 2:
+			patchDim = shape[1]
+		case 4:
+			patchDim = shape[1] * shape[2] * shape[3]
+		}
+		channels := int(cfg.NumChannels)
+		if channels <= 0 {
+			channels = 3
+		}
+		if patchDim > 0 && patchDim%channels == 0 {
+			patch := int(math.Round(math.Sqrt(float64(patchDim / channels))))
+			if patch > 0 && channels*patch*patch == patchDim {
+				cfg.PatchSize = int32(patch)
+			}
+		}
+	}
+	if cfg.HiddenSize > 0 && cfg.NumAttentionHeads > 0 {
+		cfg.HeadDim = cfg.HiddenSize / cfg.NumAttentionHeads
+	}
+	if cfg.NumKeyValueHeads == 0 {
+		cfg.NumKeyValueHeads = cfg.NumAttentionHeads
+	}
+	for i := 0; ; i++ {
+		prefix := core.Sprintf("encoder.layers.%d", i)
+		if _, ok := model.WeightAny(weights,
+			prefix+".self_attn.q_proj.weight",
+			prefix+".self_attn.q_proj.linear.weight",
+			prefix+".attention.q_proj.weight",
+			prefix+".attention.q_proj.linear.weight",
+		); !ok {
+			if i > 0 {
+				cfg.NumHiddenLayers = int32(i)
+			}
+			break
+		}
+	}
+	return normalizeGemma4VisionConfig(cfg)
+}

go/pkg/model/gemma4/vision_infer_test.go

@@ -0,0 +1,45 @@
+// SPDX-Licence-Identifier: EUPL-1.2
+
+package gemma4
+
+import (
+	"testing"
+
+	"dappco.re/go/mlx/pkg/safetensors"
+)
+
+// TestInferGemma4VisionConfig pins the shape-derived dims: hidden_size + patch_size from the
+// patch-embedding weight (588 = 3·14·14 → patch 14), and the encoder-layer count by walking the q_projs.
+func TestInferGemma4VisionConfig(t *testing.T) {
+	weights := map[string]safetensors.Tensor{
+		"patch_embedding.weight":                   {Shape: []int{1152, 588}},
+		"encoder.layers.0.self_attn.q_proj.weight": {Shape: []int{1152, 1152}},
+		"encoder.layers.1.self_attn.q_proj.weight": {Shape: []int{1152, 1152}},
+	}
+	cfg := &Gemma4VisionConfig{}
+	cfg.NumAttentionHeads = 16 // promoted from the embedded neutral core
+	got := inferGemma4VisionConfig(weights, cfg)
+	if got.HiddenSize != 1152 {
+		t.Fatalf("HiddenSize = %d, want 1152", got.HiddenSize)
+	}
+	if got.PatchSize != 14 {
+		t.Fatalf("PatchSize = %d, want 14 (round(sqrt(588/3)))", got.PatchSize)
+	}
+	if got.NumHiddenLayers != 2 {
+		t.Fatalf("NumHiddenLayers = %d, want 2", got.NumHiddenLayers)
+	}
+}
+
+// TestGemma4VisionShouldBuildEncoderTower pins the tower/no-tower decision by model_type.
+func TestGemma4VisionShouldBuildEncoderTower(t *testing.T) {
+	unified := &Gemma4TextConfig{}
+	unified.ModelType = "gemma4_unified"
+	if gemma4VisionShouldBuildEncoderTower(unified) {
+		t.Fatal("gemma4_unified declares no encoder tower")
+	}
+	dense := &Gemma4TextConfig{}
+	dense.ModelType = "gemma4"
+	if !gemma4VisionShouldBuildEncoderTower(dense) {
+		t.Fatal("gemma4 should build an encoder tower")
+	}
+}