Keras中自定义Kronecker积Lambda层：batch_size维度处理困境

Hey there, let's get that Kronecker product working with your Keras model! The error you're seeing (ValueError: too many values to unpack (expected 3)) is exactly what you suspected: your kronecker_product3D function is expecting 3D tensors, but Keras passes 4D tensors everywhere—with the first dimension reserved for the batch size.

The Core Problem #

When you call m1, n1, o1 = tensor1.get_shape().as_list(), tensor1 is actually a 4D tensor with shape (batch_size, height, width, channels). Unpacking 4 values into 3 variables throws that error right away. Plus, we need to make sure the Kronecker product is computed independently for every sample in the batch, which your current code doesn't account for.

Modified Code to Handle 4D Tensors #

Here's an updated version of your functions that properly handles the batch dimension, even when it's dynamic (i.e., None at graph construction time):

import keras.backend as K

def kronecker_product(mat1, mat2):
    """Computes Kronecker product of two 2D matrices (with batch dimension)"""
    batch_size = K.shape(mat1)[0]
    m1, n1 = K.int_shape(mat1)[1:]
    m2, n2 = K.int_shape(mat2)[1:]
    
    # Reshape for broadcasting: (batch, m1, 1, n1, 1) and (batch, 1, m2, 1, n2)
    mat1_rsh = K.reshape(mat1, (batch_size, m1, 1, n1, 1))
    mat2_rsh = K.reshape(mat2, (batch_size, 1, m2, 1, n2))
    
    # Element-wise multiply and reshape back to (batch, m1*m2, n1*n2)
    return K.reshape(mat1_rsh * mat2_rsh, (batch_size, m1 * m2, n1 * n2))

def kronecker_product3D(tensors):
    tensor1 = tensors[0]  # Shape: (batch, m1, n1, o1)
    tensor2 = tensors[1]  # Shape: (batch, m2, n2, o2)
    
    batch_size = K.shape(tensor1)[0]
    m1, n1, o1 = K.int_shape(tensor1)[1:]
    m2, n2, o2 = K.int_shape(tensor2)[1:]
    
    x_list = []
    for ind1 in range(o1):
        for ind2 in range(o2):
            # Extract 2D matrices for each channel pair (includes batch dimension)
            mat1 = tensor1[:, :, :, ind1]  # (batch, m1, n1)
            mat2 = tensor2[:, :, :, ind2]  # (batch, m2, n2)
            
            # Compute Kronecker product for each sample in the batch
            kron_mat = kronecker_product(mat1, mat2)
            x_list.append(kron_mat)
    
    # Concatenate all channel pairs along the last dimension to get (batch, m1*m2, n1*n2, o1*o2)
    return K.concatenate(x_list, axis=-1)

Key Changes Explained #

1. Batch Dimension Preservation: We use K.shape(tensor1)[0] to get the dynamic batch size (since it might be None during graph setup), and keep it in all reshaping operations so each sample is processed independently.
2. 4D Tensor Handling: We slice the input tensors to get 3D (batch + 2D matrix) slices for each channel, then compute the Kronecker product across the batch.
3. Correct Concatenation: Instead of using the Keras Concatenate() layer class, we use K.concatenate() (the backend function) inside the Lambda layer, since we need to return a tensor directly.

Using the Updated Function #

Your Lambda layer code stays almost the same—just make sure you're using the modified kronecker_product3D:

cb = Convolution2D(12, (3,3), padding='same')(x)
x = Lambda(kronecker_product3D)([x, cb])

This should resolve the unpack error and correctly compute the Kronecker product between your input and convolution output, while respecting the batch dimension.

内容的提问来源于stack exchange，提问作者Bety