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


_cpp_source = r"""
#include <torch/extension.h>
torch::Tensor fused_postprocess(torch::Tensor x, torch::Tensor offset);
"""

_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>

__device__ __forceinline__ float activate(float x, float offset) {
    x = x > 0.0f ? x : x * 0.2f;
    x = x + offset;
    x = x < -1.0f ? -1.0f : x;
    x = x > 1.0f ? 1.0f : x;
    return (0.5f * x) * (1.0f + erff(x * 0.7071067811865475244f));
}

__global__ void postprocess_vectorized(
    float4* __restrict__ x,
    const float* __restrict__ offset,
    int count,
    int spatial_vectors,
    int channels
) {
    const int stride = blockDim.x * gridDim.x;
    for (int i = blockIdx.x * blockDim.x + threadIdx.x;
         i < count; i += stride) {
        const int channel = (i / spatial_vectors) % channels;
        const float bias = offset[channel];
        const float4 value = x[i];
        x[i] = make_float4(
            activate(value.x, bias),
            activate(value.y, bias),
            activate(value.z, bias),
            activate(value.w, bias)
        );
    }
}

__global__ void postprocess_scalar(
    float* __restrict__ x,
    const float* __restrict__ offset,
    int count,
    int spatial,
    int channels
) {
    const int stride = blockDim.x * gridDim.x;
    for (int i = blockIdx.x * blockDim.x + threadIdx.x;
         i < count; i += stride) {
        const int channel = (i / spatial) % channels;
        x[i] = activate(x[i], offset[channel]);
    }
}

torch::Tensor fused_postprocess(torch::Tensor x, torch::Tensor offset) {
    TORCH_CHECK(x.is_cuda() && offset.is_cuda(), "Expected CUDA tensors");
    TORCH_CHECK(x.device() == offset.device(), "Devices must match");
    TORCH_CHECK(x.scalar_type() == at::kFloat &&
                offset.scalar_type() == at::kFloat, "Expected float32");
    TORCH_CHECK(x.is_contiguous() && offset.is_contiguous(),
                "Expected contiguous tensors");
    TORCH_CHECK(x.dim() == 5, "Expected NCDHW input");
    TORCH_CHECK(offset.numel() == x.size(1), "Invalid offset size");
    TORCH_CHECK(x.numel() <= 2147483647LL, "Tensor is too large");

    const c10::cuda::CUDAGuard guard(x.device());
    const int count = static_cast<int>(x.numel());
    if (count == 0) {
        return x;
    }

    const int channels = static_cast<int>(x.size(1));
    const int spatial =
        static_cast<int>(x.size(2) * x.size(3) * x.size(4));
    constexpr int threads = 256;
    const auto stream = at::cuda::getCurrentCUDAStream();

    if (spatial % 4 == 0) {
        const int vectors = count / 4;
        const int blocks = std::min((vectors + threads - 1) / threads, 4096);
        postprocess_vectorized<<<blocks, threads, 0, stream>>>(
            reinterpret_cast<float4*>(x.data_ptr<float>()),
            offset.data_ptr<float>(),
            vectors,
            spatial / 4,
            channels
        );
    } else {
        const int blocks = static_cast<int>(
            std::min((static_cast<int64_t>(count) + threads - 1) / threads,
                     int64_t(4096))
        );
        postprocess_scalar<<<blocks, threads, 0, stream>>>(
            x.data_ptr<float>(),
            offset.data_ptr<float>(),
            count,
            spatial,
            channels
        );
    }

    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return x;
}
"""

_fused = load_inline(
    name="conv3d_fused_leaky_add_clamp_gelu",
    cpp_sources=_cpp_source,
    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.device == self.sum_tensor.device
            and x.is_contiguous()
            and self.sum_tensor.is_contiguous()
            and tuple(self.sum_tensor.shape) == (x.shape[1], 1, 1, 1)
            and x.numel() <= 2147483647
            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
        x = torch.clamp(x, min=-1.0, max=1.0)
        return F.gelu(x)
```