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

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

__device__ __forceinline__ float activate(float x, float bias) {
    float y = (x >= 0.0f ? x : 0.2f * x) + bias;
    if (y >= 1.0f) return 0.8413447460685429f;
    if (y <= -1.0f) return -0.1586552539314571f;
    return 0.5f * y * (1.0f + erff(y * 0.7071067811865475f));
}

__global__ void fused_vector_kernel(
    float4* __restrict__ x,
    const float* __restrict__ bias,
    int64_t count,
    int64_t spatial_vectors,
    int64_t channels
) {
    int64_t stride = static_cast<int64_t>(blockDim.x) * gridDim.x;
    for (int64_t i = static_cast<int64_t>(blockIdx.x) * blockDim.x
                     + threadIdx.x;
         i < count; i += stride) {
        float b = bias[(i / spatial_vectors) % channels];
        float4 v = x[i];
        v.x = activate(v.x, b);
        v.y = activate(v.y, b);
        v.z = activate(v.z, b);
        v.w = activate(v.w, b);
        x[i] = v;
    }
}

__global__ void fused_scalar_kernel(
    float* __restrict__ x,
    const float* __restrict__ bias,
    int64_t count,
    int64_t spatial,
    int64_t channels
) {
    int64_t stride = static_cast<int64_t>(blockDim.x) * gridDim.x;
    for (int64_t i = static_cast<int64_t>(blockIdx.x) * blockDim.x
                     + threadIdx.x;
         i < count; i += stride) {
        x[i] = activate(x[i], bias[(i / spatial) % channels]);
    }
}

torch::Tensor fused_postprocess(torch::Tensor x, torch::Tensor bias) {
    TORCH_CHECK(x.is_cuda() && bias.is_cuda(), "Expected CUDA tensors");
    TORCH_CHECK(x.device() == bias.device(), "Device mismatch");
    TORCH_CHECK(x.scalar_type() == at::kFloat &&
                bias.scalar_type() == at::kFloat, "Expected float32");
    TORCH_CHECK(x.dim() == 5 && x.is_contiguous(), "Expected contiguous NCDHW");
    TORCH_CHECK(bias.is_contiguous() && bias.numel() == x.size(1),
                "Expected one bias per channel");

    const c10::cuda::CUDAGuard guard(x.device());
    const auto stream = at::cuda::getCurrentCUDAStream();
    const int64_t n = x.numel();
    if (n == 0) return x;

    const int64_t spatial = x.size(2) * x.size(3) * x.size(4);
    const int64_t channels = x.size(1);
    constexpr int threads = 256;

    if (spatial % 4 == 0 &&
        reinterpret_cast<uintptr_t>(x.data_ptr<float>()) % 16 == 0) {
        const int64_t count = n / 4;
        const int blocks = static_cast<int>(
            std::min<int64_t>(4096, (count + threads - 1) / threads));
        fused_vector_kernel<<<blocks, threads, 0, stream>>>(
            reinterpret_cast<float4*>(x.data_ptr<float>()),
            bias.data_ptr<float>(), count, spatial / 4, channels);
    } else {
        const int blocks = static_cast<int>(
            std::min<int64_t>(4096, (n + threads - 1) / threads));
        fused_scalar_kernel<<<blocks, threads, 0, stream>>>(
            x.data_ptr<float>(), bias.data_ptr<float>(),
            n, spatial, channels);
    }
    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return x;
}
"""

_fused = load_inline(
    name="conv3d_fused_leaky_add_clamp_gelu_v1",
    cpp_sources=(
        "torch::Tensor fused_postprocess(torch::Tensor x, torch::Tensor bias);"
    ),
    cuda_sources=_cuda_source,
    functions=["fused_postprocess"],
    extra_cflags=["-O3"],
    extra_cuda_cflags=["-O3", "--fmad=false"],
    verbose=False,
)


class ModelNew(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, sum_tensor_shape):
        super().__init__()
        self.conv = nn.Conv3d(in_channels, out_channels, kernel_size)
        self.sum_tensor = nn.Parameter(torch.randn(sum_tensor_shape))

    def forward(self, x):
        x = self.conv(x)
        if (
            x.is_cuda
            and x.dtype == torch.float32
            and self.sum_tensor.dtype == torch.float32
            and x.is_contiguous()
            and self.sum_tensor.is_contiguous()
            and tuple(self.sum_tensor.shape) == (x.shape[1], 1, 1, 1)
            and not (
                torch.is_grad_enabled()
                and (x.requires_grad or self.sum_tensor.requires_grad)
            )
        ):
            return _fused.fused_postprocess(x, self.sum_tensor)

        x = F.leaky_relu(x, negative_slope=0.2)
        x = x + self.sum_tensor
        return F.gelu(torch.clamp(x, min=-1.0, max=1.0))
```