I'm relatively new to Keras and I am about to build a Dueling Q-Network to train a KI. I found a code snippet to build a model that surprisingly seems to work. I just have no idea why, because I'm not too familiar with lambda expressions in Keras. Can anybody explain me how exactly the creation of the lambda-layer in the following model works?
Thank you very much in advantage!

def build_model():



    model = Sequential()

    model.add(Dense(units=16, activation='relu', input_dim = 2))

    model.add(Dense(units=32, activation='relu'))

    model.add(Dense(units=9, activation='relu'))



    #I definitely don't understand how the following layer works:

    model.add(Lambda(lambda i: K.expand_dims(i[:,0],-1) + i[:,1:] - K.mean(i[:,1:], keepdims=True), output_shape=(8,)))



    model.add(Dense(units=8, activation='linear'))

    model.compile(loss='mse',

    optimizer = RMSprop(lr=0.001) )

    return model

I am not familiar with your particular area of research, but I can tell you what that layer is doing. A Lambda layer is when you want to define a custom operation on the inputs that don't come from anything that is predefined from Keras. Specifically, you want to apply some custom operation to a tensor coming into the layer that Keras doesn't already handle.

The input into the Lambda layer is an anonymous function where the input is the tensor that is coming into this layer. Note however that you can also specify any function or operation into this layer and it doesn't have to be an anonymous function... so long as it operates on the input tensor and produces an output one. You then define the operation you want to perform with this input tensor and it creates a corresponding output tensor that would be fed to the next layer. This behaviour is of course assuming a feedforward network which is what I see here. You can think of an anonymous function as a one time function that would be used to perform operations, but you don't want them lingering around later as you have no need for them anymore after you specify what to do with the input tensor.

lambda i thus denotes that you are creating an anonymous function which the Lambda layer would be operating on the input tensor defined as i. K.expand_dims ensures that you add in singleton dimensions for the purposes of broadcasting. In this case, we wish to take the first column of the input tensor i[:,0] which becomes a 1D array and making sure that the input tensor is a 2D array with a single column (i.e. going from a N, array to a N x 1 array). The -1 argument is the axis you want to expand on. Setting this to -1 simply expands the very last dimension which in this case the last dimension is the first (and the only) dimension.

If you're not used to broadcasting, the addition operation to this expanded array is a bit hard to understand but once you get the hang of it, it's one of the most powerful mechanisms in computing. i[:,1:] slices the input tensor so that we consider the tensor from the second column to the end. Under the hood, adding this sliced tensor with the expanded single column i[:,0] means that this column gets replicated and is added to every single column in i[:,1:] individually.

For example if i[:,0] was [1, 2, 3, 4] and i[:,1:] was [[4, 4, 4, 4], [5, 5, 5, 5], [6, 6, 6, 6], performing K.expand_dims(i[:,0], -1) + i[:,1:] results in [[5, 6, 7, 8], [6, 7, 8, 9], [7, 8, 9, 10]].

The last piece of the puzzle is this: K.mean(i[:,1:], keepdims=True). We take K.expand_dims(i[:,0], -1) + i[:,1:] then subtract this with K.mean(i[:,1:], keepdims=True). K.mean in this context will find the average of all values in the tensor for all the rows from the second column onwards. This is the default behaviour of the operation. Depending on how you use K.mean, one or more of the dimensions may drop. An additional input into K.mean is the axis which allows you to specify which dimensions you want to analyze the average of in the tensor. For example, if you did axis=0, this finds the mean of each column individually.
This would reduce to a 1D tensor of values. With the keepdims keyword, if you specified keepdims=True, this would ensure that the tensor is still 2D with the number of columns being 1 (i.e. a N x 1 tensor instead of a N, tensor). The default behaviour is false.

Therefore, by doing the K.mean operation, we ensure that the final result is 1 x 1 and this value is subtracted from every value of the K.expand_dims(i[:,0],-1) + i[:,1:] result. This is again possible due to broadcasting.

Finally, we make sure that the output shape of this operation gives a 1D tensor of size 8.

tl;dr

This operation is a custom one where we take the first column of an input tensor, add it to all of the other columns from the second column onwards and subtract every value of this result with the average of all of the other columns from the second column onwards. Additionally, we constrain the output size of the tensor so that it is 1D with size 8.