fix lint

Author: YunchaoYang

recipes/lm/sft/scripts/run_qwen35_gsm8k.sh

@@ -24,9 +24,7 @@ class TestQwen35Attention:
     def test_forward_produces_correct_shape(self) -> None:
         """Output shape is (B, S, model_dim)."""
         sdpa = NaiveSDPA(IdentityBias())
-        attn = Qwen35Attention(
-            model_dim=64, num_heads=4, sdpa=sdpa, head_dim=16
-        )
+        attn = Qwen35Attention(model_dim=64, num_heads=4, sdpa=sdpa, head_dim=16)
         attn = attn.to(device)
 
         seqs = torch.randn(2, 8, 64, device=device)
@@ -41,9 +39,7 @@ def test_forward_produces_correct_shape(self) -> None:
     def test_output_gating_effect(self) -> None:
         """When gate output is all zeros, attention output should be near zero."""
         sdpa = NaiveSDPA(IdentityBias())
-        attn = Qwen35Attention(
-            model_dim=64, num_heads=4, sdpa=sdpa, head_dim=16
-        )
+        attn = Qwen35Attention(model_dim=64, num_heads=4, sdpa=sdpa, head_dim=16)
         attn = attn.to(device)
 
         seqs = torch.randn(1, 4, 64, device=device)
@@ -147,9 +143,7 @@ def test_qk_norm_applied(self) -> None:
     def test_incremental_kv_cache_matches_full_forward(self) -> None:
         """Token-by-token decoding with KV cache produces the same logits as causal full-sequence forward."""
         sdpa = NaiveSDPA(CausalAttentionBias())
-        attn = Qwen35Attention(
-            model_dim=64, num_heads=4, sdpa=sdpa, head_dim=16
-        )
+        attn = Qwen35Attention(model_dim=64, num_heads=4, sdpa=sdpa, head_dim=16)
         attn = attn.to(device)
         attn.eval()
 

tests/unit/models/qwen/test_qwen35_attention.py

@@ -29,9 +29,7 @@ def test_full_attention_layer_forward(self) -> None:
         """Full attention layer produces correct shape."""
         model_dim = 64
         sdpa = NaiveSDPA(IdentityBias())
-        self_attn = Qwen35Attention(
-            model_dim, num_heads=4, sdpa=sdpa, head_dim=16
-        )
+        self_attn = Qwen35Attention(model_dim, num_heads=4, sdpa=sdpa, head_dim=16)
         ffn = GLUFeedForwardNetwork(model_dim, 128, bias=False, inner_dim_scale=1.0)
         layer = Qwen35DecoderLayer(
             "full_attention",

tests/unit/models/qwen/test_qwen35_decoder_layer.py

@@ -87,9 +87,9 @@ def test_rmsnorm_weight_conversion(self) -> None:
             hf_state_dict[f"model.layers.{i}.input_layernorm.weight"] = torch.zeros(
                 config.model_dim
             )
-            hf_state_dict[
-                f"model.layers.{i}.post_attention_layernorm.weight"
-            ] = torch.zeros(config.model_dim)
+            hf_state_dict[f"model.layers.{i}.post_attention_layernorm.weight"] = (
+                torch.zeros(config.model_dim)
+            )
         hf_state_dict["model.norm.weight"] = torch.zeros(config.model_dim)
         hf_state_dict["model.embed_tokens.weight"] = torch.zeros(
             config.vocab_size, config.model_dim
@@ -112,9 +112,7 @@ def test_gdn_norm_weight_not_converted(self) -> None:
         config = self._make_small_config()
 
         # Simulate HF state dict with GDN norm weight
-        hf_state_dict: dict[str, object] = {
-            "model.embed_tokens.weight": torch.zeros(1)
-        }
+        hf_state_dict: dict[str, object] = {"model.embed_tokens.weight": torch.zeros(1)}
         hf_state_dict["model.layers.0.linear_attn.norm.weight"] = (
             torch.ones(config.linear_value_head_dim) * 0.5
         )
@@ -264,7 +262,13 @@ def test_rmsnorm_weight_reversed(self) -> None:
 
         # HF weights should be 0.0 (1.0 - 1.0)
         for key in hg_state_dict:
-            if key.endswith(("input_layernorm.weight", "post_attention_layernorm.weight", "model.norm.weight")):
+            if key.endswith(
+                (
+                    "input_layernorm.weight",
+                    "post_attention_layernorm.weight",
+                    "model.norm.weight",
+                )
+            ):
                 weight = hg_state_dict[key]
                 assert isinstance(weight, torch.Tensor)
                 assert_close(weight, torch.zeros_like(weight))
@@ -341,7 +345,10 @@ def test_to_hg_config(self) -> None:
         assert data["num_experts"] == config.num_experts
         assert data["num_experts_per_tok"] == config.num_experts_per_tok
         assert data["moe_intermediate_size"] == config.moe_intermediate_size
-        assert data["shared_expert_intermediate_size"] == config.shared_expert_intermediate_size
+        assert (
+            data["shared_expert_intermediate_size"]
+            == config.shared_expert_intermediate_size
+        )
         assert data["router_aux_loss_coef"] == config.router_aux_loss_coef
 
     def test_state_dict_round_trip(self) -> None:
@@ -441,9 +448,9 @@ def test_visual_and_mtp_keys_filtered(self) -> None:
         }
         result = convert_qwen35_state_dict(dict(state_dict), config)
         for key in result:
-            assert not key.startswith(("model.visual.", "mtp.")), (
-                f"Unexpected key not filtered: {key}"
-            )
+            assert not key.startswith(
+                ("model.visual.", "mtp.")
+            ), f"Unexpected key not filtered: {key}"
 
     def test_text_only_format_still_works(self) -> None:
         """model.layers.* (text-only format) is still handled correctly."""
@@ -475,7 +482,7 @@ def test_end_to_end_vl_checkpoint(self) -> None:
         vl_state_dict: dict[str, object] = {}
         for k, v in hg_state_dict.items():
             if k.startswith("model."):
-                vl_state_dict["model.language_model." + k[len("model."):]] = v
+                vl_state_dict["model.language_model." + k[len("model.") :]] = v
             else:
                 vl_state_dict[k] = v
         # Add visual/mtp keys

tests/unit/models/qwen/test_qwen35_interop.py

@@ -64,9 +64,9 @@ def test_logits_are_raw_pre_softmax(self) -> None:
 class TestQwen35Experts:
     def test_forward_output_shape(self) -> None:
         """Experts output shape matches input shape (T, D)."""
-        experts = Qwen35Experts(
-            num_experts=4, model_dim=32, expert_inner_dim=16
-        ).to(device)
+        experts = Qwen35Experts(num_experts=4, model_dim=32, expert_inner_dim=16).to(
+            device
+        )
         torch.nn.init.normal_(experts.gate_up_proj, std=0.01)
         torch.nn.init.normal_(experts.down_proj, std=0.01)
 
@@ -84,9 +84,9 @@ def test_forward_output_shape(self) -> None:
 
     def test_weighted_output(self) -> None:
         """Output is weighted by routing weights — zero weight means no contribution."""
-        experts = Qwen35Experts(
-            num_experts=4, model_dim=16, expert_inner_dim=8
-        ).to(device)
+        experts = Qwen35Experts(num_experts=4, model_dim=16, expert_inner_dim=8).to(
+            device
+        )
         torch.nn.init.normal_(experts.gate_up_proj, std=0.01)
         torch.nn.init.normal_(experts.down_proj, std=0.01)