```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_deconv3d(
    torch::Tensor x, torch::Tensor weight,
    torch::Tensor conv_bias, torch::Tensor bias);

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

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

__device__ __forceinline__ float finish(float value, float bias) {
    float sigmoid = 1.0f / (1.0f + __expf(-(value + 3.0f)));
    float result = (value * sigmoid) / 6.0f - bias;
    result = result < -1.0f ? -1.0f : result;
    result = result > 1.0f ? 1.0f : result;
    return result;
}

// Separate parity classes remove stride tests and boundary branches.
// Each thread computes all 16 output channels at one spatial position,
// then reduces them without writing the convolution intermediate.
template<int PD, int PH, int PW>
__global__ void deconv_reduce_kernel(
    const float* __restrict__ x,
    const float* __restrict__ weight,
    const float* __restrict__ conv_bias,
    const float* __restrict__ bias,
    float* __restrict__ output,
    int D, int H, int W, int count)
{
    int index = blockIdx.x * blockDim.x + threadIdx.x;
    if (index >= count) return;

    const int DW = W - PW;
    const int DH = H - PH;
    const int DD = D - PD;

    int qw = index % DW;
    int remaining = index / DW;
    int qh = remaining % DH;
    remaining /= DH;
    int qd = remaining % DD;
    int batch = remaining / DD;

    const int spatial = D * H * W;
    const int input_base = batch * 3 * spatial;
    float values[16];

    #pragma unroll
    for (int c = 0; c < 16; ++c)
        values[c] = 0.0f;

    #pragma unroll
    for (int ic = 0; ic < 3; ++ic) {
        #pragma unroll
        for (int zd = 0; zd < (PD ? 2 : 1); ++zd) {
            constexpr int kd_start = PD ? 0 : 1;
            int kd = kd_start + 2 * zd;
            int id = qd + (PD ? 1 - zd : 0);

            #pragma unroll
            for (int yh = 0; yh < (PH ? 2 : 1); ++yh) {
                constexpr int kh_start = PH ? 0 : 1;
                int kh = kh_start + 2 * yh;
                int ih = qh + (PH ? 1 - yh : 0);

                #pragma unroll
                for (int xw = 0; xw < (PW ? 2 : 1); ++xw) {
                    constexpr int kw_start = PW ? 0 : 1;
                    int kw = kw_start + 2 * xw;
                    int iw = qw + (PW ? 1 - xw : 0);

                    float v = __ldg(
                        x + input_base + ic * spatial
                          + (id * H + ih) * W + iw);
                    int wbase = ic * 16 * 27 + kd * 9 + kh * 3 + kw;

                    #pragma unroll
                    for (int c = 0; c < 16; ++c) {
                        float w = __ldg(weight + wbase + c * 27);
                        values[c] = fmaf(v, w, values[c]);
                    }
                }
            }
        }
    }

    float maximum = -INFINITY;
    #pragma unroll
    for (int c = 0; c < 16; ++c) {
        values[c] += __ldg(conv_bias + c);
        maximum = fmaxf(maximum, values[c]);
    }
    if (isinf(maximum)) maximum = 0.0f;

    float sum = 0.0f;
    #pragma unroll
    for (int c = 0; c < 16; ++c)
        sum += __expf(values[c] - maximum);

    const float value = logf(sum) + maximum;
    const int OD = 2 * D - 1;
    const int OH = 2 * H - 1;
    const int OW = 2 * W - 1;
    const int out_index =
        ((batch * OD + 2 * qd + PD) * OH + 2 * qh + PH) * OW
        + 2 * qw + PW;

    output[out_index] = finish(value, __ldg(bias));
}

template<int PD, int PH, int PW>
void launch_parity(
    const float* x, const float* weight,
    const float* conv_bias, const float* bias, float* output,
    int N, int D, int H, int W, cudaStream_t stream)
{
    const int count = N * (D - PD) * (H - PH) * (W - PW);
    if (count <= 0) return;
    constexpr int threads = 128;
    deconv_reduce_kernel<PD, PH, PW>
        <<<(count + threads - 1) / threads, threads, 0, stream>>>(
            x, weight, conv_bias, bias, output, D, H, W, count);
}

torch::Tensor fused_deconv3d(
    torch::Tensor x, torch::Tensor weight,
    torch::Tensor conv_bias, torch::Tensor bias)
{
    const c10::cuda::CUDAGuard guard(x.device());
    const int N = x.size(0);
    const int D = x.size(2);
    const int H = x.size(3);
    const int W = x.size(4);

    auto output = torch::empty(
        {N, 1, 2 * D - 1, 2 * H - 1, 2 * W - 1}, x.options());

    const float* xp = x.data_ptr<float>();
    const float* wp = weight.data_ptr<float>();
    const float* cp = conv_bias.data_ptr<float>();
    const float* bp = bias.data_ptr<float>();
    float* op = output.data_ptr<float>();
    cudaStream_t stream = at::cuda::getCurrentCUDAStream();

    launch_parity<0, 0, 0>(xp, wp, cp, bp, op, N, D, H, W, stream);
    launch_parity<0, 0, 1>(xp, wp, cp, bp, op, N, D, H, W, stream);
    launch_parity<0, 1, 0>(xp, wp, cp, bp, op, N, D, H, W, stream);
    launch_parity<0, 1, 1>(xp, wp, cp, bp, op, N, D, H, W, stream);
    launch_parity<1, 0, 0>(xp, wp, cp, bp, op, N, D, H, W, stream);
    launch_parity<1, 0, 1>(xp, wp, cp, bp, op, N, D, H, W, stream);
    launch_parity<1, 1, 0>(xp, wp, cp, bp, op, N, D, H, W, stream);
    launch_parity<1, 1, 1>(xp, wp, cp, bp, op, N, D, H, W, stream);

    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return output;
}

template<int CHANNELS>
__global__ void postprocess_kernel(
    const float* __restrict__ input,
    const float* __restrict__ bias,
    float* __restrict__ output,
    int spatial, int total, int channels)
{
    int index = blockIdx.x * blockDim.x + threadIdx.x;
    if (index >= total) return;

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

    float maximum = -INFINITY;
    float sum = 0.0f;

    if constexpr (CHANNELS > 0) {
        float values[CHANNELS];
        #pragma unroll
        for (int c = 0; c < CHANNELS; ++c) {
            values[c] = input[base + c * spatial];
            maximum = fmaxf(maximum, values[c]);
        }
        if (isinf(maximum)) maximum = 0.0f;

        #pragma unroll
        for (int c = 0; c < CHANNELS; ++c)
            sum += __expf(values[c] - maximum);
    } else {
        for (int c = 0; c < channels; ++c)
            maximum = fmaxf(maximum, input[base + c * spatial]);
        if (isinf(maximum)) maximum = 0.0f;

        for (int c = 0; c < channels; ++c)
            sum += __expf(input[base + c * spatial] - maximum);
    }

    output[index] = finish(logf(sum) + maximum, bias[0]);
}

torch::Tensor fused_postprocess(torch::Tensor x, torch::Tensor bias)
{
    const c10::cuda::CUDAGuard guard(x.device());
    const int channels = x.size(1);
    const int spatial = x.size(2) * x.size(3) * x.size(4);
    const int total = x.size(0) * spatial;

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

    constexpr int threads = 256;
    const int blocks = (total + threads - 1) / threads;
    cudaStream_t stream = at::cuda::getCurrentCUDAStream();

    if (channels == 16) {
        postprocess_kernel<16><<<blocks, threads, 0, stream>>>(
            x.data_ptr<float>(), bias.data_ptr<float>(),
            output.data_ptr<float>(), spatial, total, channels);
    } else {
        postprocess_kernel<0><<<blocks, threads, 0, stream>>>(
            x.data_ptr<float>(), bias.data_ptr<float>(),
            output.data_ptr<float>(), spatial, total, channels);
    }
    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return output;
}
"""

_ops = load_inline(
    name="fused_deconv3d_parity_lse_v2",
    cpp_sources=_cpp_source,
    cuda_sources=_cuda_source,
    functions=["fused_deconv3d", "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,
        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))

        conv = self.conv_transpose
        self._specialized = (
            in_channels == 3
            and out_channels == 16
            and conv.kernel_size == (3, 3, 3)
            and conv.stride == (2, 2, 2)
            and conv.padding == (1, 1, 1)
            and conv.dilation == (1, 1, 1)
            and conv.output_padding == (0, 0, 0)
            and conv.groups == 1
        )

    def forward(self, x):
        conv = self.conv_transpose
        if (
            self._specialized
            and x.is_cuda
            and x.ndim == 5
            and x.dtype == torch.float32
            and conv.weight.dtype == torch.float32
            and conv.bias.dtype == torch.float32
            and self.bias.dtype == torch.float32
            and not torch.is_autocast_enabled()
        ):
            return _ops.fused_deconv3d(
                x.contiguous(),
                conv.weight.contiguous(),
                conv.bias,
                self.bias,
            )

        x = conv(x)
        if (
            x.is_cuda
            and x.ndim == 5
            and x.dtype == torch.float32
            and self.bias.dtype == torch.float32
        ):
            return _ops.fused_postprocess(x.contiguous(), self.bias)

        x = torch.logsumexp(x, dim=1, keepdim=True)
        x = x * torch.sigmoid(x + 3) / 6
        return torch.clamp(x - self.bias, min=-1, max=1)
```