human
I wrote the below code

    (r, c) = image_shape
    (pr, pc) = pool_shape
    (rs, cs) = pool_stride
    batch = bc01.shape[0]
    channel = bc01.shape[1]
    rng = make_theano_rng(rng, 2022, which_method='multinomial')
    def last_pool(im_shp, p_shp, p_strd):
        rval = int(numpy.ceil((float((im_shp - p_shp)) / p_strd)))
        assert (((p_strd * rval) + p_shp) >= im_shp)
        assert (((p_strd * (rval - 1)) + p_shp) < im_shp)
        return rval
    last_pool_r = (last_pool(image_shape[0], pool_shape[0], pool_stride[0]) * pool_stride[0])
    required_r = (last_pool_r + pr)
    last_pool_c = (last_pool(image_shape[1], pool_shape[1], pool_stride[1]) * pool_stride[1])
    required_c = (last_pool_c + pc)
    res_r = (int(numpy.floor((last_pool_r / rs))) + 1)
    res_c = (int(numpy.floor((last_pool_c / cs))) + 1)
    for bc01v in get_debug_values(bc01):
        assert (not contains_inf(bc01v))
        assert (bc01v.shape[2] == image_shape[0])
        assert (bc01v.shape[3] == image_shape[1])
    padded = tensor.alloc(0.0, batch, channel, required_r, required_c)
    name = bc01.name
    if (name is None):
        name = 'anon_bc01'
    bc01 = tensor.set_subtensor(padded[:, :, 0:r, 0:c], bc01)
    bc01.name = ('zero_padded_' + name)
    window = tensor.alloc(0.0, batch, channel, res_r, res_c, pr, pc)
    window.name = ('unravlled_winodows_' + name)
    for row_within_pool in xrange(pool_shape[0]):
        row_stop = ((last_pool_r + row_within_pool) + 1)
        for col_within_pool in xrange(pool_shape[1]):
            col_stop = ((last_pool_c + col_within_pool) + 1)
            win_cell = bc01[:, :, row_within_pool:row_stop:rs, col_within_pool:col_stop:cs]
            window = tensor.set_subtensor(window[:, :, :, :, row_within_pool, col_within_pool], win_cell)
    norm = window.sum(axis=[4, 5])
    norm = tensor.switch(tensor.eq(norm, 0.0), 1.0, norm)
    norm = (window / norm.dimshuffle(0, 1, 2, 3, 'x', 'x'))
    res = (window * norm).sum(axis=[4, 5])
    res.name = ('pooled_' + name)
    return res.reshape((batch, channel,...

What's a good function header?

Here's a good function header?
assistant
#Here's a good function header.

def weighted_max_pool_bc01(bc01, pool_shape, pool_stride, image_shape, rng=None):