apply_over_axes() applies the function sequentially to each specified axis, and it preserves the original dimensionality by keeping singleton dimensions for the axes it operates on - numpy.apply_over_axes

For your scenario you can try np.sum() with a tuple of axes

c_simplified = b.sum(axis=(1,2))
print(c_simplified.shape)

In a Picture

import numpy as np
b = np.random.randint(6, size=(100, 101, 102))

result_sum = b.sum(axis=(1, 2))  

result_max = b.max(axis=(1, 2)) 

result_mean = b.mean(axis=(1, 2))

output#

Sum shape: (100,)
Max shape: (100,)
Mean shape: (100,)

Edit 1:

f: Specifies the axis along which np.sum operates. Without it, the function cannot correctly sum over the intended axis.

axes parameter in np.apply_over_axes: Specifies the axes over which the function f should be applied iteratively, reducing them to size 1.

The axis parameter in your function f is necessary because np.sum needs to know which axis to operate on. Without it, the function call will fail, as np.sum defaults to summing over all axes if axis isn't specified, which conflicts with the iterative application of np.apply_over_axes

More can be found at - https://numpy.org/doc/stable/reference/generated/numpy.apply_over_axes.html

Summing Over Axes 1 and 2

import numpy as np

def custom_sum(array, axes):
 
    axes = tuple(axes)
    return np.sum(array, axis=axes)

b = np.random.randint(6, size=(100, 101, 102))
c = custom_sum(b, axes=(1, 2))
print(c.shape)  

output

(100,)

Second Largest Element Over Axes 1 and 2

you can reshape the array, sort along the flattened axes

axes = tuple(axes)
flattened = np.reshape(array, (-1,) + array.shape[len(axes):])
sorted_array = np.sort(flattened, axis=1)
print(sorted_array[:, -2])

If you have a sufficiently recent NumPy, you can do

m_mean = m.mean(axis=(1, 2))

I believe this was introduced in 1.7, though I'm not sure. The documentation was only updated to reflect this in 1.10, but it worked earlier than that.

If your NumPy is too old, you can take the mean a bit more manually:

m_mean = m.sum(axis=2).sum(axis=1) / np.prod(m.shape[1:3])

These will both produce 1-dimensional results. If you really want that extra length-1 axis, you can do something like m_mean = m_mean[:, np.newaxis] to put the extra axis there.

In numpy 1.7 you can give multiple axis to np.mean:

d.mean(axis=tuple(range(1, d.ndim)))

I am guessing this will perform similarly to the other proposed solutions, unless reshaping the array to flatten all dimensions triggers a copy of the data, in which case this should be much faster. So this is probably going to give a more consistent performance.