It seems like you are looking for interpolate (a function in nn.functional):

import torch.nn.functional as nnf

x = torch.rand(5, 1, 44, 44)
out = nnf.interpolate(x, size=(224, 224), mode='bicubic', align_corners=False)

If you really care about the accuracy of the interpolation, you should have a look at ResizeRight: a pytorch/numpy package that accurately deals with all sorts of "edge cases" when resizing images. This can have an effect when directly merging features of different scales: inaccurate interpolation may result in misalignments.

You can instead choose to go with tensor.reshape(new_shape) or torch.reshape(tensor, new_shape) as in:

# a `Variable` tensor
In [15]: ten = torch.randn(6, requires_grad=True)

# this would throw RuntimeError error
In [16]: ten.resize_(2, 3)
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-16-094491c46baa> in <module>()
----> 1 ten.resize_(2, 3)

RuntimeError: cannot resize variables that require grad

The above RuntimeError can be resolved or avoided by using tensor.reshape(new_shape)

In [17]: ten.reshape(2, 3)
Out[17]: 
tensor([[-0.2185, -0.6335, -0.0041],
        [-1.0147, -1.6359,  0.6965]])

# yet another way of changing tensor shape
In [18]: torch.reshape(ten, (2, 3))
Out[18]: 
tensor([[-0.2185, -0.6335, -0.0041],
        [-1.0147, -1.6359,  0.6965]])

Reducing [512, 4, 1000] to [512, 1] will result in the loss of a lot of data because the product of dimensions 2 and 3 (4 \* 1000 = 4000) cannot be compressed into 1 without losing data.

As long as you are aware of what you are doing though you could do something like this:

input_tensor = torch.randn(512, 4, 1000)  # your tensor
output_tensor = input_tensor.mean(dim=[1,2], keepdim=True)
print(output_tensor.shape)  # should output torch.Size([512, 1])

But if you want to preserve your data you are better off doing something like this:

input_tensor = torch.randn(512, 4, 1000)  # your tensor
output_tensor = input_tensor.view(512, -1)
print(output_tensor.shape)  # should output torch.Size([512, 4000])

Note: You may already know this but just in case; the -1 acts as a placeholder that PyTorch will fill in to keep the correct number of total elements in the tensor

One approach using TF.resize is to flatten the batch and depth dimensions, perform the resize, then recover the initial depth dimension:

>>> a_flat = a.swapaxes(1,2).flatten(0,1)     # (B*D, C,  H,   W)
>>> c = TF.resize(a_flat , (200, 200))        # (B*D, C, 200, 200)
>>> b = b.view(*a.shape[:3], *c.shape[-2:])   # (B, D, C, 200, 200)