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

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

torch::Tensor fused_postprocess_cuda(
    torch::Tensor x, torch::Tensor bias);
"""

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

template <typename scalar_t, int CHANNELS>
__global__ void fused_postprocess_kernel(
    const scalar_t* __restrict__ x,
    const scalar_t* __restrict__ bias,
    scalar_t* __restrict__ output,
    int64_t spatial,
    int64_t count,
    int channels)
{
    using acc_t = at::acc_type<scalar_t, true>;

    const int64_t index =
        static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
    if (index >= count) return;

    const int64_t batch = index / spatial;
    const int64_t position = index - batch * spatial;
    const int64_t base = batch * channels * spatial + position;

    acc_t maximum = -static_cast<acc_t>(INFINITY);
    acc_t sum = 0;

    if constexpr (CHANNELS == 16) {
        acc_t values[16];

        #pragma unroll
        for (int c = 0; c < 16; ++c) {
            values[c] = static_cast<acc_t>(x[base + c * spatial]);
            maximum = values[c] > maximum ? values[c] : maximum;
        }

        // Match torch.logsumexp's handling of infinite maxima.
        if (isinf(maximum)) maximum = 0;

        #pragma unroll
        for (int c = 0; c < 16; ++c) {
            sum += exp(values[c] - maximum);
        }
    } else {
        for (int c = 0; c < channels; ++c) {
            const acc_t value =
                static_cast<acc_t>(x[base + c * spatial]);
            maximum = value > maximum ? value : maximum;
        }

        if (isinf(maximum)) maximum = 0;

        for (int c = 0; c < channels; ++c) {
            sum += exp(
                static_cast<acc_t>(x[base + c * spatial]) - maximum);
        }
    }

    // Cast intermediate results to preserve the input dtype's rounding.
    const scalar_t lse_scalar =
        static_cast<scalar_t>(maximum + log(sum));
    const acc_t lse = static_cast<acc_t>(lse_scalar);

    const scalar_t shifted_scalar =
        static_cast<scalar_t>(lse + static_cast<acc_t>(3));
    const scalar_t sigmoid_scalar = static_cast<scalar_t>(
        static_cast<acc_t>(1) /
        (static_cast<acc_t>(1) +
         exp(-static_cast<acc_t>(shifted_scalar))));

    const scalar_t product_scalar = static_cast<scalar_t>(
        lse * static_cast<acc_t>(sigmoid_scalar));
    const scalar_t scaled_scalar = static_cast<scalar_t>(
        static_cast<acc_t>(product_scalar) / static_cast<acc_t>(6));
    const scalar_t subtracted_scalar = static_cast<scalar_t>(
        static_cast<acc_t>(scaled_scalar) -
        static_cast<acc_t>(bias[0]));

    acc_t result = static_cast<acc_t>(subtracted_scalar);

    // Comparisons preserve NaNs, as torch.clamp does.
    if (result < static_cast<acc_t>(-1)) result = -1;
    if (result > static_cast<acc_t>(1)) result = 1;

    output[index] = static_cast<scalar_t>(result);
}

torch::Tensor fused_postprocess_cuda(
    torch::Tensor x, torch::Tensor bias)
{
    TORCH_CHECK(x.is_cuda() && bias.is_cuda(),
                "Inputs must be CUDA tensors");
    TORCH_CHECK(x.dim() == 5 && x.is_contiguous(),
                "x must be contiguous NCDHW");
    TORCH_CHECK(bias.numel() == 1,
                "bias must contain one element");
    TORCH_CHECK(x.device() == bias.device(),
                "Inputs must be on the same device");
    TORCH_CHECK(x.scalar_type() == bias.scalar_type(),
                "Inputs must have the same dtype");

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

    const int channels = static_cast<int>(x.size(1));
    const int64_t spatial = x.size(2) * x.size(3) * x.size(4);
    const int64_t count = x.size(0) * spatial;

    auto output = torch::empty(
        {x.size(0), 1, x.size(2), x.size(3), x.size(4)},
        x.options());

    if (count == 0) return output;

    constexpr int threads = 256;
    const int blocks = static_cast<int>((count + threads - 1) / threads);
    const auto stream = at::cuda::getCurrentCUDAStream();

    AT_DISPATCH_FLOATING_TYPES_AND2(
        at::ScalarType::Half,
        at::ScalarType::BFloat16,
        x.scalar_type(),
        "fused_postprocess",
        [&] {
            if (channels == 16) {
                fused_postprocess_kernel<scalar_t, 16>
                    <<<blocks, threads, 0, stream>>>(
                        x.data_ptr<scalar_t>(),
                        bias.data_ptr<scalar_t>(),
                        output.data_ptr<scalar_t>(),
                        spatial, count, channels);
            } else {
                fused_postprocess_kernel<scalar_t, -1>
                    <<<blocks, threads, 0, stream>>>(
                        x.data_ptr<scalar_t>(),
                        bias.data_ptr<scalar_t>(),
                        output.data_ptr<scalar_t>(),
                        spatial, count, channels);
            }
        });

    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return output;
}
"""

_fused_ops = load_inline(
    name="convtranspose3d_fused_lse_sigmoid_clamp",
    cpp_sources=_cpp_source,
    cuda_sources=_cuda_source,
    functions=["fused_postprocess_cuda"],
    extra_cflags=["-O3"],
    extra_cuda_cflags=["-O3", "--fmad=false"],
    verbose=False,
)


class ModelNew(nn.Module):
    def __init__(
        self,
        in_channels,
        out_channels,
        kernel_size,
        stride,
        padding,
        bias_shape,
    ):
        super().__init__()
        self.conv_transpose = nn.ConvTranspose3d(
            in_channels,
            out_channels,
            kernel_size,
            stride=stride,
            padding=padding,
        )
        self.bias = nn.Parameter(torch.randn(1, 1, 1, 1))

    def forward(self, x):
        x = self.conv_transpose(x)
        return _fused_ops.fused_postprocess_cuda(
            x.contiguous(), self.bias
        )
```