While implementing a Kronecker-product
for pedagogical reasons (without using the obvious and readily available np.kron()
), I obtained a 4 dimensional array as an intermediate result, which I've to reshape to get the final result.
But, I still can't wrap my head around reshaping these high dimensional arrays. I have this 4D
array:
array([[[[ 0, 0],
[ 0, 0]],
[[ 5, 10],
[15, 20]]],
[[[ 6, 12],
[18, 24]],
[[ 7, 14],
[21, 28]]]])
This is of shape (2, 2, 2, 2)
and I'd like to reshape it to (4,4)
. One might think that this is obvious to do with
np.reshape(my4darr, (4,4))
But, the above reshape does not give me the expected result which is:
array([[ 0, 5, 0, 10],
[ 6, 7, 12, 14],
[ 0, 15, 0, 20],
[18, 21, 24, 28]])
As you can see, all the elements in the expected result are present in the 4D
array. I just can't get the hang of doing the reshape correctly as needed. In addition to the answer, some explanation of how to do the reshape
for such high dimensional arrays would be really helpful. Thanks!
General idea for
nd
tond
transformationThe idea with such
nd
tond
transformation is using just two things - Permute axes (withnumpy.transpose
ornumpy.rollaxis
if the needed permute order is a rolled one ornumpy.swapaxes
if just two axes need to be swapped) and Reshape.Permute axes : To get the order such that the flattened version corresponds to the flattened version of output. So, if you somehow end up using it twice, look again because you shouldn't.
Reshape : To split the axes or bring the final output to the desired shape. Splitting axes is needed mostly at the start, when the input is of lower-dim and we are needed to split into blocks. Again, you shouldn't need this more than twice.
Hence, generally we would have three steps :
Back-tracking method
The safest way to solve, given the input and output is through, what one could call as the back-tracking method, i.e. split the axes of the input (when going from smaller
nd
to biggernd
) or split the axes of the output (when going from biggernd
to smallernd
). The idea with the splitting is to bring the number of dims of the smallernd
one same as the biggernd
one. Then, study the strides of the output and match it up against the input to get the required permute order. Finally, a reshape (default way or C order) might be needed at the end, if the final one is a smallernd
one, to merge axes.If both input and output are of same number of dims, then we would need to split both and break into blocks and study their strides against each other. In such cases, we should have the additional input parameter of block sizes, but that's probably off-topic.
Example
Let's use this specific case to demonstrate how to apply those strategies. In here, the input is
4D
, while output is2D
. So, most probably, we won't need reshape to split. So, we need to start with permuting axes. Since, the final output is not4D
, but a2D
one, we would need a reshape at the end.Now, the input here is :
The expected output is :
Also, this is a bigger
nd
to smallernd
transformation, so the back-tracking method would involve, splitting the output and studying its strides and matching up against the corresponding values in input :Hence, the permuted order needed is
(2,0,3,1)
:Then, simply reshape to the expected shape :
More examples
I dug up my history and found few
Q&As
based onnd
tond
transformations. These could serve as other example cases, albeit with lesser explanation (mostly). As mentioned earlier, at most tworeshapes
and at most oneswapaxes
/transpose
did the job everywhere. They are listed below :It seems like you're looking for a
transpose
followed by areshape
.To help you understand why a transposition is needed, let's analyse your incorrectly shaped output (obtained by a single
reshape
call) to understand why it is incorrect.A simple 2D reshaped version of this result (without any transposition) looks like this -
Now consider this output with respect to your expected output -
You'll notice that your actual result is obtained by a Z-like traversal of your incorrectly shaped output -
This implies that you must move over the array in varying strides to get your actual result. In conclusion, a simple reshape is not enough. You must transpose the original array, in such a manner that these Z-like elements are made to be contiguous to each other, such that a subsequent reshape call gives you the output you need.
To understand how to transpose correctly, you should trace the elements along the input and figure out what axes you need to jump to get to each one in the output. The transposition follows accordingly. Divakar's answer does a sterling job of explaining this.
The Divarkar's answer is great, though sometimes it is easier for me just to check all possible cases which
transpose
andreshape
cover.For example, the following code
gives me all what one can get from 4-dimensional array using
transpose
+reshape
. Since, I know how the output should look like, I will just pick the permutation that showed me the correct answer. If I didn't get what I wanted, thentranspose
+reshape
is not general enough to cover my case and I have to do something more complicated.