Delete deletion-eligible test_kahan_summation_cpu

Summary:
Oncall test cleanup for the `stl_multimodal` rotation. TestX flags
`TestAnyPrecisionOptimizer.test_kahan_summation_cpu` (test IDs
`281475243659032` and `281475243855546`) as eligible for deletion — it sits in
`DISABLED_FAILING` trunk state with an open `FAILURE` issue, well past the
60-day zero-value threshold.

The test hard-coded four bfloat16 compensation-buffer tensors captured from a
seeded two-step optimizer run and compared them at `atol=1e-4`. At bfloat16
precision those buffers hold values near `1e-5`, so the assertion tolerance is
wider than the quantities being checked and the test was pinning RNG output
rather than Kahan-summation correctness. Deleting is the right call here
rather than re-recording the golden buffers.

`test_kahan_summation_gpu` is left in place: it is `gpu_test()`-gated, was not
flagged, and still covers the same `use_kahan_summation=True` path.
`_test_adam_equivalence`, `test_adam_equivalence_cpu`, `_test_bfloat16_states`,
and `test_bfloat16_states_cpu` continue to cover `AnyPrecisionAdamW` on CPU.

Differential Revision: D114397064

Author: twmoveon

tests/modules/layers/test_anyprecision_optimizer.py

@@ -136,120 +136,6 @@ def test_bfloat16_states_cpu(
     ):
         self._test_bfloat16_states(device="cpu")
 
-    def test_kahan_summation_cpu(self, device="cpu"):
-        """verify that AnyPrecision is properly using Kahan summation when specified (momentum, variance).
-        uses precomputed result tensors as comparison for the compensation buffers."""
-        simple_model = nn.Sequential(nn.Linear(5, 10), nn.GELU(), nn.Linear(10, 2))
-        simple_model.to(torch.bfloat16)
-        simple_model.to(device)
-
-        anyprecision_adam = AnyPrecisionAdamW(
-            simple_model.parameters(),
-            variance_dtype=torch.bfloat16,
-            momentum_dtype=torch.bfloat16,
-            use_kahan_summation=True,
-            compensation_buffer_dtype=torch.bfloat16,
-        )
-
-        # pre-computed kahan buffer tensors for comparing results.
-        # values determined by comparison to reference implementation.
-        expected_kahan_buffer_param0 = torch.tensor(
-            [
-                [-1.5259e-05, 8.2397e-04, 1.7166e-04, 5.1880e-04, 1.1444e-05],
-                [-4.5776e-05, -1.1826e-04, 9.1553e-04, 3.0518e-04, -4.3869e-05],
-                [4.5776e-05, -2.8229e-04, 5.6028e-05, 2.8610e-06, -8.0872e-04],
-                [2.6703e-05, -2.6703e-04, 5.0068e-05, -2.9755e-04, 1.0014e-04],
-                [2.8610e-05, -4.1962e-05, -6.7139e-04, -9.9659e-05, 3.8147e-06],
-                [-3.0518e-05, -2.1839e-04, 6.0320e-05, 2.8992e-04, -7.6294e-06],
-                [0.0000e00, -3.4332e-04, 1.7166e-04, 4.8828e-04, 3.3951e-04],
-                [-2.8849e-05, -1.2457e-05, -1.1444e-05, -6.3324e-04, -4.9591e-05],
-                [-3.5286e-05, 3.4332e-04, -4.9353e-05, 9.4223e-04, -3.7956e-04],
-                [5.4932e-04, -7.6294e-06, 3.4523e-04, 3.3760e-04, 4.5586e-04],
-            ],
-            dtype=torch.bfloat16,
-        )
-
-        expected_kahan_buffer_param1 = torch.tensor(
-            [
-                4.4823e-05,
-                -4.7445e-05,
-                4.5776e-05,
-                4.5538e-05,
-                4.5776e-05,
-                3.8624e-05,
-                2.8849e-05,
-                1.5259e-05,
-                -5.5313e-05,
-                1.4114e-04,
-            ],
-            dtype=torch.bfloat16,
-        )
-
-        expected_kahan_buffer_param2 = torch.tensor(
-            [
-                [
-                    -5.3406e-05,
-                    -1.2815e-05,
-                    0.0000e00,
-                    -4.2725e-04,
-                    -3.4332e-05,
-                    2.2888e-05,
-                    1.2589e-04,
-                    -3.1281e-04,
-                    0.0000e00,
-                    -4.4632e-04,
-                ],
-                [
-                    -5.3406e-05,
-                    -1.5259e-05,
-                    0.0000e00,
-                    -4.2725e-04,
-                    4.5586e-04,
-                    2.2888e-05,
-                    3.8147e-06,
-                    -7.6294e-06,
-                    0.0000e00,
-                    4.1962e-05,
-                ],
-            ],
-            dtype=torch.bfloat16,
-        )
-
-        expected_kahan_buffer_param3 = torch.tensor(
-            [-4.5776e-05, -1.5259e-05], dtype=torch.bfloat16
-        )
-
-        expected_kahan_buffers = [
-            expected_kahan_buffer_param0,
-            expected_kahan_buffer_param1,
-            expected_kahan_buffer_param2,
-            expected_kahan_buffer_param3,
-        ]
-
-        for i in range(2):
-            anyprecision_adam.zero_grad()
-            inp = torch.randn(
-                5,
-                5,
-                dtype=torch.bfloat16,
-                device=next(simple_model.parameters()).device,
-            )
-            simple_model(inp).sum().backward()
-            anyprecision_adam.step()
-
-        for group in anyprecision_adam.param_groups:
-            for index, p in enumerate(group["params"]):
-                state = anyprecision_adam.state[p]
-                pcomp = state["compensation"]
-                assert pcomp.dtype == torch.bfloat16
-
-                assert_expected(
-                    pcomp,
-                    expected_kahan_buffers[index],
-                    atol=1e-4,
-                    rtol=1e-4,
-                )
-
     @gpu_test()
     def test_kahan_summation_gpu(self, device="cuda"):
         """verify that AnyPrecision is properly using Kahan summation when specified (momentum, variance).