predicted_value = np.array([i for i in range(9, 33)])

Make a small 2d array, and a nested list from it:

In [241]: A=np.arange(6).reshape(2,3)
In [242]: alist= A.tolist()
In [243]: alist
Out[243]: [[0, 1, 2], [3, 4, 5]]

One way of iterating on the list:

In [244]: for row in alist:
     ...:     for item in row:
     ...:         print(item)
     ...:         
0
1
2
3
4
5

works just same for the array

In [245]: for row in A:
     ...:     for item in row:
     ...:         print(item)
     ...:         
0
1
2
3
4
5

Now neither is good if you want to modify elements. But for crude iteration over all elements this works.

WIth the array I can easily treat it was a 1d

In [246]: [i for i in A.flat]
Out[246]: [0, 1, 2, 3, 4, 5]

I could also iterate with nested indices

In [247]: [A[i,j] for i in range(A.shape[0]) for j in range(A.shape[1])]
Out[247]: [0, 1, 2, 3, 4, 5]

In general it is better to work with arrays without iteration. I give these iteration examples to clearup some confusion.

Did you had a look at numpy.ndindex? This could do the trick:

a = np.ndindex(6,6)

You could have some more information on Is there a Python equivalent of range(n) for multidimensional ranges?

Seems like you've skipped over some intro Python chapters. With a list there are several simple ways of iterating:

In [1]: alist = ['a','b','c']                                                   
In [2]: for i in alist: print(i)        # on the list itself                                                
a
b
c
In [3]: len(alist)                                                              
Out[3]: 3
In [4]: for i in range(len(alist)): print(i,alist[i])  # index is ok                 
0 a
1 b
2 c
In [5]: for i,v in enumerate(alist): print(i,v)   # but enumerate is simpler            
0 a
1 b
2 c

Note the indexes. range(3) is sufficient. alist[3] produces an error.

In [6]: arr = np.arange(6).reshape(2,3)                                         
In [7]: arr                                                                     
Out[7]: 
array([[0, 1, 2],
       [3, 4, 5]])
In [8]: for row in arr: 
   ...:     for col in row: 
   ...:         print(row,col) 
   ...:                                                                         
[0 1 2] 0
[0 1 2] 1
[0 1 2] 2
[3 4 5] 3
[3 4 5] 4
[3 4 5] 5

The shape is a tuple. The row count is then arr.shape[0], and columns arr.shape[1]. Or you can 'unpack' both at once:

In [9]: arr.shape                                                               
Out[9]: (2, 3)
In [10]: n,m = arr.shape                                                        
In [11]: [arr[i,j] for i in range(n) for j in range(m)]                         
Out[11]: [0, 1, 2, 3, 4, 5]

But we can get the same flat list of values with ravel and optional conversion to list:

In [12]: arr.ravel()                                                            
Out[12]: array([0, 1, 2, 3, 4, 5])
In [13]: arr.ravel().tolist()                                                   
Out[13]: [0, 1, 2, 3, 4, 5]

But usually with numpy arrays, you shouldn't be iterating at all. Learn enough of the numpy basics so you can work with the whole array, not elements.

nditer can be used, as the other answer shows, to iterate through an array in a flat manner, but there are a number of details about it that could easily confuse a beginner. There are a couple of intro pages to nditer, but they should be read in full. Usually I discourage its use.

In [14]: for i in np.nditer(arr): 
    ...:     print(i, type(i), i.shape) 
    ...:                                                                        
0 <class 'numpy.ndarray'> ()        # this element is a 0d array, not a scalar integer
1 <class 'numpy.ndarray'> ()
2 <class 'numpy.ndarray'> ()
... 

Iterating with ndenumerate or on the tolist produce different types of elements. The type may matter if you try to do more than display the value, so be careful.

In [15]: list(np.ndenumerate(arr))                                              
Out[15]: [((0, 0), 0), ((0, 1), 1), ((0, 2), 2), ((1, 0), 3), ((1, 1), 4), ((1, 2), 5)]
In [16]: for ij, v in np.ndenumerate(arr): 
    ...:     print(ij, v, type(v)) 
    ...:                                                                        
(0, 0) 0 <class 'numpy.int64'>
(0, 1) 1 <class 'numpy.int64'>
...
In [17]: for i, v in enumerate(arr.ravel().tolist()): 
    ...:     print(i, v, type(v)) 
    ...:                                                                        
0 0 <class 'int'>
1 1 <class 'int'>
...