x = torch.randn(1, 16, 16, device="cuda", dtype=torch.bfloat16)
        m = nn.Sequential(
            nn.Linear(16, 32, bias=False, device="cuda", dtype=torch.bfloat16),
            nn.Sequential(
                nn.ReLU(),
                nn.Linear(32, 64, bias=False, device="cuda", dtype=torch.bfloat16),
            ),
        )
        config = Float8LinearConfig.from_recipe_name(recipe_name)

        @torch.no_grad()
        def mean_absolute_percentage_error(x_ref, x):
            tmp = torch.abs(x_ref - x) / torch.clamp(torch.abs(x_ref), min=1e-9)
            # trim to avoid values close to 0 from
            # significantly impacting the results
            tmp = torch.clamp(tmp, max=1e3)
            return torch.mean(tmp)

        iter_counter = 0
        iter_fqn_gemm_name_to_data = {}

        @torch._dynamo.disable
        def debug_logging_fn(fqn, gemm_name, a_hp, b_hp, a_fp8, b_fp8):
            """
            Example debugging function - this is user defined, easy to customize
            1. captures M, K, N
            2. captures MAPE for high precision vs float8 gemm
            4. leaves data on GPU, so the user can move it to CPU at their
               convenience
            """
            M, K = a_hp.shape
            K2, N = b_hp.shape
            assert K == K2
            res_hp = a_hp @ b_hp
            res_fp8 = a_fp8 @ b_fp8
            mape = mean_absolute_percentage_error(res_hp, res_fp8)
            iter_fqn_gemm_name_to_data[(iter_counter, fqn, gemm_name)] = (M, K, N), mape

        object.__setattr__(config, "_debug_logging_fn", debug_logging_fn)
        m = convert_to_float8_training(m, config=config)
        _populate_debug_fqns(m)

        # iter 0
        m = torch.compile(m)
        y = m(x)
        y.sum().backward()

        # iter 1
        iter_counter += 1
        m = torch.compile(m)
        y = m(x)
        y.sum().backward()