```python
import torch
import torch.nn as nn
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 <cmath>

constexpr int THREADS = 256;
constexpr int CHUNK = 8192;

__device__ __forceinline__ float warp_sum(float value) {
    for (int offset = 16; offset > 0; offset >>= 1)
        value += __shfl_down_sync(0xffffffff, value, offset);
    return value;
}

__device__ __forceinline__ float warp_max(float value) {
    for (int offset = 16; offset > 0; offset >>= 1)
        value = fmaxf(value, __shfl_down_sync(0xffffffff, value, offset));
    return value;
}

__device__ __forceinline__ float block_sum(float value, float* scratch) {
    int lane = threadIdx.x & 31;
    int warp = threadIdx.x >> 5;
    value = warp_sum(value);
    if (lane == 0)
        scratch[warp] = value;
    __syncthreads();

    value = threadIdx.x < 8 ? scratch[lane] : 0.0f;
    if (warp == 0)
        value = warp_sum(value);
    if (threadIdx.x == 0)
        scratch[0] = value;
    __syncthreads();
    return scratch[0];
}

__device__ __forceinline__ float block_max(float value, float* scratch) {
    int lane = threadIdx.x & 31;
    int warp = threadIdx.x >> 5;
    value = warp_max(value);
    if (lane == 0)
        scratch[warp] = value;
    __syncthreads();

    value = threadIdx.x < 8 ? scratch[lane] : -INFINITY;
    if (warp == 0)
        value = warp_max(value);
    if (threadIdx.x == 0)
        scratch[0] = value;
    __syncthreads();
    return scratch[0];
}

__global__ void spatial_sums(
    const float* __restrict__ x,
    float* __restrict__ partial,
    int64_t spatial,
    int chunks
) {
    __shared__ float scratch[8];

    int64_t row = blockIdx.x;
    int chunk = blockIdx.y;
    int64_t begin = int64_t(chunk) * CHUNK;
    int64_t end = begin + CHUNK;
    if (end > spatial)
        end = spatial;

    const float* row_ptr = x + row * spatial;
    float sum = 0.0f;

    if ((spatial & 3) == 0) {
        const float4* vector_ptr =
            reinterpret_cast<const float4*>(row_ptr);
        for (int64_t i = begin / 4 + threadIdx.x;
             i < end / 4; i += THREADS) {
            float4 v = vector_ptr[i];
            sum += v.x;
            sum += v.y;
            sum += v.z;
            sum += v.w;
        }
    } else {
        for (int64_t i = begin + threadIdx.x; i < end; i += THREADS)
            sum += row_ptr[i];
    }

    sum = block_sum(sum, scratch);
    if (threadIdx.x == 0)
        partial[row * chunks + chunk] = sum;
}

__global__ void pooled_conv_logsumexp(
    const float* __restrict__ partial,
    const float* __restrict__ weight,
    const float* __restrict__ conv_bias,
    const float* __restrict__ extra_bias,
    float* __restrict__ output,
    int in_channels,
    int out_channels,
    int kernel_area,
    int chunks,
    float inverse_output_area
) {
    extern __shared__ float shared[];
    float* input_sums = shared;
    float* logits = shared + in_channels;
    float* scratch = logits + out_channels;

    int batch = blockIdx.x;
    int tid = threadIdx.x;

    for (int ic = tid; ic < in_channels; ic += THREADS) {
        const float* p =
            partial + (int64_t(batch) * in_channels + ic) * chunks;
        float sum = 0.0f;
        for (int j = 0; j < chunks; ++j)
            sum += p[j];
        input_sums[ic] = sum * inverse_output_area;
    }
    __syncthreads();

    // With stride=1 and padding=0, every input pixel contributes
    // every kernel coefficient to the spatial sum of the output.
    float local_max = -INFINITY;
    for (int oc = tid; oc < out_channels; oc += THREADS) {
        float value = 0.0f;
        for (int ic = 0; ic < in_channels; ++ic) {
            const float* w =
                weight + (int64_t(ic) * out_channels + oc) * kernel_area;
            float weight_sum = 0.0f;
            for (int k = 0; k < kernel_area; ++k)
                weight_sum += w[k];
            value = fmaf(input_sums[ic], weight_sum, value);
        }
        value += conv_bias[oc];
        value += extra_bias[oc];
        logits[oc] = value;
        local_max = fmaxf(local_max, value);
    }

    float maximum = block_max(local_max, scratch);
    // Ensure every thread has consumed scratch before it is reused.
    __syncthreads();

    float local_sum = 0.0f;
    for (int oc = tid; oc < out_channels; oc += THREADS)
        local_sum += expf(logits[oc] - maximum);

    float total = block_sum(local_sum, scratch);
    if (tid == 0)
        output[batch] = 10.0f * (maximum + logf(total));
}

torch::Tensor fused_forward(
    torch::Tensor x,
    torch::Tensor weight,
    torch::Tensor conv_bias,
    torch::Tensor extra_bias
) {
    c10::cuda::CUDAGuard guard(x.device());

    const int64_t batch = x.size(0);
    const int in_channels = x.size(1);
    const int out_channels = weight.size(1);
    const int64_t height = x.size(2);
    const int64_t width = x.size(3);
    const int kh = weight.size(2);
    const int kw = weight.size(3);
    const int64_t spatial = height * width;
    const int chunks = (spatial + CHUNK - 1) / CHUNK;

    auto output = torch::empty({batch, 1}, x.options());
    if (batch == 0)
        return output;

    auto partial =
        torch::empty({batch, in_channels, chunks}, x.options());

    cudaStream_t stream = at::cuda::getCurrentCUDAStream();

    spatial_sums<<<dim3(batch * in_channels, chunks), THREADS, 0, stream>>>(
        x.data_ptr<float>(),
        partial.data_ptr<float>(),
        spatial,
        chunks
    );
    C10_CUDA_KERNEL_LAUNCH_CHECK();

    const float inverse_output_area =
        1.0f / float((height + kh - 1) * (width + kw - 1));
    const size_t shared_bytes =
        (in_channels + out_channels + 8) * sizeof(float);

    pooled_conv_logsumexp<<<batch, THREADS, shared_bytes, stream>>>(
        partial.data_ptr<float>(),
        weight.data_ptr<float>(),
        conv_bias.data_ptr<float>(),
        extra_bias.data_ptr<float>(),
        output.data_ptr<float>(),
        in_channels,
        out_channels,
        kh * kw,
        chunks,
        inverse_output_area
    );
    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return output;
}
"""

_extension = load_inline(
    name="pooled_transposed_conv_lse_cuda_v1",
    cpp_sources="""
        torch::Tensor fused_forward(
            torch::Tensor x,
            torch::Tensor weight,
            torch::Tensor conv_bias,
            torch::Tensor extra_bias);
    """,
    cuda_sources=_cuda_source,
    functions=["fused_forward"],
    extra_cflags=["-O3"],
    extra_cuda_cflags=["-O3"],
    verbose=False,
)


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

    def forward(self, x):
        conv = self.conv_transpose
        if (
            x.is_cuda
            and x.dtype == torch.float32
            and conv.weight.dtype == torch.float32
            and self.bias.dtype == torch.float32
            and tuple(self.bias.shape) == (conv.out_channels, 1, 1)
            and x.ndim == 4
            and x.shape[1] == conv.in_channels
            and x.shape[2] > 0
            and x.shape[3] > 0
            and conv.in_channels + conv.out_channels + 8 <= 12288
            and not torch.is_autocast_enabled()
        ):
            return _extension.fused_forward(
                x.contiguous(),
                conv.weight.contiguous(),
                conv.bias.contiguous(),
                self.bias.contiguous(),
            )

        x = conv(x)
        x = torch.mean(x, dim=(2, 3), keepdim=True)
        x = x + self.bias
        x = torch.logsumexp(x, dim=1, keepdim=True)
        return torch.sum(x, dim=(2, 3)) * 10.0
```