How to iterate over a 3 dimensional tensor - numpy

Question

I have a tensor say:
y_true = np.array([[[1.], [0.], [3.]], [[5.], [0.], [0.]]])
I want to iterate over y_true accessing all indevidual values. I want to do something like following in java:
for(i=0;i<y_true.length;i++){
arr2 = y_true[i];
for(j=0;j<arr2.length;j++){
print(arr2[j][0])
}
}.

Answer 1

Are you looking for slicing with [:,:,0]?
>>> y_true[:,:,0]
array([[1., 0., 3.],
[5., 0., 0.]])

Answer 2

There are 2 cases:
You know the rank(dimensionality) of your created numpy array in the example y_true array has rank of 3, and you can check y_true.shape property which should give you with exact size of each dimension of the y_true, then you can write as many for loops the rank of y_true and output each element separately, for example:
import numpy as np
y_true = np.array([[[1.], [0.], [3.]], [[5.], [0.], [0.]]])
dims = y_true.shape
for i in range(dims[0]):
for j in range(dims[1]):
for k in range(dims[2]):
print("Element of np array with indices {} is equal to {}".format([i, j, k], y_true[i, j, k]))
If you don't know the rank of the tensor you want to print then you can write recursive function that will print all the elements, for example:
import numpy as np
def recursively_print_elems(np_arr, idx, pos):
if pos >= len(np_arr.shape):
print("Element of np array with indeces {} is equal to: {}".format(idx, np_arr[tuple(idx)]))
return
for i in range(np_arr.shape[pos]):
idx[pos] = i
recursively_print_elems(np_arr, idx, pos + 1)
def print_elems(np_arr):
idx = [0] * len(np_arr.shape)
recursively_print_elems(np_arr, idx, 0)
y_true = np.array([[[1.], [0.], [3.]], [[5.], [0.], [0.]]])
print_elems(y_true)
The 2nd approach is more general it will work for any dimensional tensor.

Answer 3

Your array:
In [19]: y_true
Out[19]:
array([[[1.],
[0.],
[3.]],
[[5.],
[0.],
[0.]]])
In [20]: y_true.shape
Out[20]: (2, 3, 1)
With a last dimension of size 1, we can reshape it
In [21]: y_true.reshape(2,3)
Out[21]:
array([[1., 0., 3.],
[5., 0., 0.]])
Selecting on that index does just as well.
But you can access all values in order just by raveling/flattening:
In [22]: y_true.ravel()
Out[22]: array([1., 0., 3., 5., 0., 0.])
Or get a 1 iterator:
In [23]: yiter = y_true.flat
In [24]: yiter?
Type: flatiter
String form: <numpy.flatiter object at 0x1fdd200>
Length: 6
File: ~/.local/lib/python3.6/site-packages/numpy/__init__.py
Docstring: <no docstring>
Class docstring:
Flat iterator object to iterate over arrays.
A `flatiter` iterator is returned by ``x.flat`` for any array `x`.
It allows iterating over the array as if it were a 1-D array,
either in a for-loop or by calling its `next` method.
...
So instead of constructing an iterator for each dimension we can iterate on this flat one:
In [25]: for item in yiter:print(item)
1.0
0.0
3.0
5.0
0.0
0.0
ndenumerate uses this flat iterator, and returns both coordinates and values:
In [26]: list(np.ndenumerate(y_true))
Out[26]:
[((0, 0, 0), 1.0),
((0, 1, 0), 0.0),
((0, 2, 0), 3.0),
((1, 0, 0), 5.0),
((1, 1, 0), 0.0),
((1, 2, 0), 0.0)]
A variation on this is ndindex:
In [27]: indexs = np.ndindex(y_true.shape)
In [28]: for ijk in indexs:
...: print(ijk, y_true[ijk])
...:
(0, 0, 0) 1.0
(0, 1, 0) 0.0
(0, 2, 0) 3.0
(1, 0, 0) 5.0
(1, 1, 0) 0.0
(1, 2, 0) 0.0
But where possible it is better to operate on the whole array, rather than iterate. Those whole-array operations do the iteration in compiled code.