```python
import torch
import torch.nn as nn
from torch.utils.cpp_extension import load_inline

_cuda_source = r"""
#include <torch/extension.h>
#include <ATen/OpMathType.h>
#include <ATen/cuda/CUDAContext.h>
#include <c10/cuda/CUDAGuard.h>
#include <c10/cuda/CUDAException.h>
#include <cuda_runtime.h>

template <typename scalar_t>
__global__ void multiply_leaky_relu_kernel(
    const scalar_t* __restrict__ input,
    scalar_t* __restrict__ output,
    int64_t size,
    at::opmath_type<scalar_t> multiplier,
    at::opmath_type<scalar_t> negative_slope
) {
    using acc_t = at::opmath_type<scalar_t>;
    const int64_t start =
        static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
    const int64_t stride =
        static_cast<int64_t>(blockDim.x) * gridDim.x;

    for (int64_t i = start; i < size; i += stride) {
        // Preserve the intermediate rounding of the original multiplication.
        scalar_t scaled = static_cast<scalar_t>(
            static_cast<acc_t>(input[i]) * multiplier);
        acc_t value = static_cast<acc_t>(scaled);
        output[i] = static_cast<scalar_t>(
            value > acc_t(0) ? value : value * negative_slope);
    }
}

torch::Tensor multiply_leaky_relu_cuda(
    torch::Tensor input,
    double multiplier,
    double negative_slope
) {
    TORCH_CHECK(input.is_cuda(), "input must be a CUDA tensor");
    TORCH_CHECK(input.is_contiguous(), "input must be contiguous");

    const c10::cuda::CUDAGuard device_guard(input.device());
    auto output = torch::empty_like(input);
    const int64_t size = input.numel();
    if (size == 0) {
        return output;
    }

    constexpr int threads = 256;
    const int blocks = static_cast<int>(
        std::min<int64_t>((size + threads - 1) / threads, 65535));
    const auto stream = at::cuda::getCurrentCUDAStream();

    AT_DISPATCH_FLOATING_TYPES_AND2(
        at::ScalarType::Half,
        at::ScalarType::BFloat16,
        input.scalar_type(),
        "multiply_leaky_relu_cuda",
        [&] {
            using acc_t = at::opmath_type<scalar_t>;
            multiply_leaky_relu_kernel<scalar_t>
                <<<blocks, threads, 0, stream>>>(
                    input.data_ptr<scalar_t>(),
                    output.data_ptr<scalar_t>(),
                    size,
                    static_cast<acc_t>(multiplier),
                    static_cast<acc_t>(negative_slope));
        });

    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return output;
}
"""

_cpp_source = r"""
#include <torch/extension.h>

torch::Tensor multiply_leaky_relu_cuda(
    torch::Tensor input,
    double multiplier,
    double negative_slope);
"""

_fused_ops = load_inline(
    name="gemm_multiply_leaky_relu_fused_v1",
    cpp_sources=_cpp_source,
    cuda_sources=_cuda_source,
    functions=["multiply_leaky_relu_cuda"],
    extra_cflags=["-O3"],
    extra_cuda_cflags=["-O3"],
    verbose=False,
)


class ModelNew(nn.Module):
    def __init__(self, in_features, out_features, multiplier, negative_slope):
        super().__init__()
        self.gemm = nn.Linear(in_features, out_features)
        self.multiplier = multiplier
        self.leaky_relu = nn.LeakyReLU(negative_slope)

    def forward(self, x):
        x = self.gemm(x)
        return _fused_ops.multiply_leaky_relu_cuda(
            x, self.multiplier, self.leaky_relu.negative_slope
        )
```