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

_cpp_source = """
#include <torch/extension.h>
torch::Tensor fused_pool_sum_cuda(torch::Tensor x);
"""

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

template <typename T>
__device__ __forceinline__ T max_propagate_nan(T a, T b) {
    return (isnan(b) || b > a) ? b : a;
}

template <typename scalar_t>
__global__ void fused_pool_sum_kernel(
    const scalar_t* __restrict__ x,
    scalar_t* __restrict__ out,
    int64_t channels,
    int64_t depth,
    int64_t height,
    int64_t width,
    int64_t out_depth,
    int64_t out_height,
    int64_t out_width
) {
    using acc_t = at::acc_type<scalar_t, true>;
    constexpr int WARPS = 8;
    constexpr unsigned MASK = 0xffffffffu;

    const int lane = threadIdx.x & 31;
    const int warp = threadIdx.x >> 5;

    const int64_t output_index = blockIdx.x;
    int64_t position = output_index;
    const int64_t ow = position % out_width;
    position /= out_width;
    const int64_t oh = position % out_height;
    position /= out_height;
    const int64_t od = position % out_depth;
    const int64_t batch = position / out_depth;

    const int64_t volume = depth * height * width;
    const int64_t spatial_base =
        (od * 6 * height + oh * 6) * width + ow * 6;

    acc_t channel_sum = acc_t(0);

    for (int64_t channel = warp; channel < channels; channel += WARPS) {
        const scalar_t* base =
            x + (batch * channels + channel) * volume + spatial_base;

        acc_t maximum = -std::numeric_limits<acc_t>::infinity();

        // The two non-overlapping pooling windows compose into one 6x6x6 window.
        #pragma unroll
        for (int i = lane; i < 216; i += 32) {
            const int dz = i / 36;
            const int dy = (i / 6) % 6;
            const int dx = i % 6;
            const acc_t value =
                static_cast<acc_t>(base[(dz * height + dy) * width + dx]);
            maximum = max_propagate_nan(maximum, value);
        }

        #pragma unroll
        for (int offset = 16; offset > 0; offset >>= 1) {
            const acc_t other = __shfl_down_sync(MASK, maximum, offset);
            maximum = max_propagate_nan(maximum, other);
        }

        if (lane == 0) {
            channel_sum += maximum;
        }
    }

    __shared__ acc_t partial_sums[WARPS];
    if (lane == 0) {
        partial_sums[warp] = channel_sum;
    }
    __syncthreads();

    if (warp == 0) {
        acc_t total = lane < WARPS ? partial_sums[lane] : acc_t(0);

        #pragma unroll
        for (int offset = 16; offset > 0; offset >>= 1) {
            total += __shfl_down_sync(MASK, total, offset);
        }

        if (lane == 0) {
            out[output_index] = static_cast<scalar_t>(total);
        }
    }
}

torch::Tensor fused_pool_sum_cuda(torch::Tensor x) {
    TORCH_CHECK(x.is_cuda(), "Expected a CUDA tensor");
    TORCH_CHECK(x.dim() == 5, "Expected an NCDHW tensor");
    TORCH_CHECK(
        x.size(2) >= 6 && x.size(3) >= 6 && x.size(4) >= 6,
        "Spatial dimensions must be at least 6"
    );

    const c10::cuda::CUDAGuard device_guard(x.device());
    x = x.contiguous();

    const int64_t batch = x.size(0);
    const int64_t channels = x.size(1);
    const int64_t depth = x.size(2);
    const int64_t height = x.size(3);
    const int64_t width = x.size(4);
    const int64_t out_depth = depth / 6;
    const int64_t out_height = height / 6;
    const int64_t out_width = width / 6;

    auto out = torch::empty(
        {batch, 1, out_depth, out_height, out_width}, x.options()
    );

    if (out.numel() == 0) {
        return out;
    }

    const auto stream = at::cuda::getCurrentCUDAStream();

    AT_DISPATCH_FLOATING_TYPES_AND2(
        at::ScalarType::Half,
        at::ScalarType::BFloat16,
        x.scalar_type(),
        "fused_pool_sum_cuda",
        [&] {
            fused_pool_sum_kernel<scalar_t>
                <<<static_cast<unsigned int>(out.numel()), 256, 0, stream>>>(
                    x.data_ptr<scalar_t>(),
                    out.data_ptr<scalar_t>(),
                    channels,
                    depth,
                    height,
                    width,
                    out_depth,
                    out_height,
                    out_width
                );
        }
    );

    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return out;
}
"""

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


class ModelNew(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride, padding):
        super().__init__()
        self.conv_transpose = nn.ConvTranspose3d(
            in_channels,
            out_channels,
            kernel_size,
            stride=stride,
            padding=padding,
        )

    def forward(self, x):
        x = self.conv_transpose(x)
        return _fused_ops.fused_pool_sum_cuda(x)
```