To do what you're asking, just use the phrase

labeledArray = [0, x]

This way, you will get a standard list with 0 as the first element and a Numpy array as the second element.

However, in practice, you are probably trying to label for the purpose of later recall. In that case, I'd recommend you use a dictionary, as it is less confusing to keep track of:

myArrays = {}
myArrays[0] = x

Which can be used as follows:

>>> myArrays
{0: array([[1, 2, 3, 4],
   [5, 6, 7, 8]])}
>>> myArrays[0]
array([[1, 2, 3, 4],
   [5, 6, 7, 8]])

The warning you're being given is to tell you you're using a deprecated (to be removed) syntax. It suggests you use from_dict instead, for example

import numpy as np
import pandas as pd
a=pd.DataFrame.from_dict({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
},
orient='index', columns=['one', 'two', 'three'])
print(a)

This will give your intended output

   one  two  three
A    1    2      3
B    4    5      6

Explanation

The following block which you say you don't understand —

a = pd.DataFrame.from_dict({
        'A': [1, 2, 3],
        'B': [4, 5, 6]
},
orient='index', columns=['one', 'two', 'three'])
print(a)

This creates a DataFrame from a dictionary (from_dict) which we're passing in as the first parameter.

{'A': [1, 2, 3], 'B': [4, 5, 6]}

This dictionary has 2 entries, "A" and "B", each of which contain a list of numbers. If you pass this to pd.DataFrame.from_dict by itself, e.g.

a = pd.DataFrame.from_dict({
        'A': [1, 2, 3],
        'B': [4, 5, 6]
})
print(a)

You would get the following output.

   A  B
0  1  4
1  2  5
2  3  6

As you can see, the keys for the dictionary are being output as the column headers. To use the dictionary keys as (row) index headers and rotate the data you can pass in orient='index'.

a = pd.DataFrame.from_dict({
        'A': [1, 2, 3],
        'B': [4, 5, 6]
}, orient='index')
print(a)

This will give the following output.

   0  1  2
A  1  2  3
B  4  5  6

The final step is to pass in the column headers we want to use.

a = pd.DataFrame.from_dict({
        'A': [1, 2, 3],
        'B': [4, 5, 6]
},
orient='index', columns=['one', 'two', 'three'])
print(a)

Which gives the intended output

   one  two  three
A    1    2      3
B    4    5      6

The correct way to create a structured array, with values, is with a list of tuples:

In [55]: X
Out[55]: 
array([(3,)], 
      dtype=[('label1', '<i4')])

In [56]: X=np.array([(3,4)],dtype=[('label1',int),('label2',int)])

In [57]: X
Out[57]: 
array([(3, 4)], 
      dtype=[('label1', '<i4'), ('label2', '<i4')])

But I should caution you that such array is not 2d (or matrix), it is 1d with fields:

In [58]: X.shape
Out[58]: (1,)

In [59]: X.dtype
Out[59]: dtype([('label1', '<i4'), ('label2', '<i4')])

And you can't do math across fields; X*2 and X.sum() will produce errors. Using X in an equation like y = X*b + error will be hopeless.

You are probably better off working with real 2d numeric arrays, and do the mapping between labels and column numbers in your head, or with a dictionary.

Or use Pandas.

You can try this:

>>> import numpy as np

>>> a = np.array([[11, 12, 13],
              [14, 16, 13],
              [17, 15, 11],
              [12, 14, 15]])

>>> np.argmax(a, axis=1) + 1

array([3, 2, 1, 3], dtype=int64)

np.argmax gives the indices of the max values in the specified axis. So,

>>> np.argmax(a, axis=1)
array([2, 1, 0, 2], dtype=int64)

Then all you need to do is add 1 to it.

If the labels of equal values are contiguous, as in your example, then you may use np.add.reduceat:

>>> lab
array([2, 2, 2, 2, 2, 3, 3, 0, 0, 0, 0, 1])
>>> idx = np.r_[0, 1 + np.where(lab[1:] != lab[:-1])[0]]
>>> np.add.reduceat(arr, idx)
array([[110,   7,   5, 117],   # 2
       [  0,   0,   0,   0],   # 3
       [  0,   0,   0,   0],   # 0
       [ 13,   2,   0,  11]])  # 1

if they are not contiguous, then use np.argsort to align the array and labels such that labels of the same values are next to each other:

>>> i = np.argsort(lab)
>>> lab, arr = lab[i], arr[i, :] # aligns array and labels such that labels
>>> lab                          # are sorted and equal labels are contiguous
array([0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 3, 3])
>>> idx = np.r_[0, 1 + np.where(lab[1:] != lab[:-1])[0]]
>>> np.add.reduceat(arr, idx)
array([[  0,   0,   0,   0],  # 0
       [ 13,   2,   0,  11],  # 1
       [110,   7,   5, 117],  # 2
       [  0,   0,   0,   0]]) # 3

or alternatively use groupby from pandas library:

>>> pd.DataFrame(arr).groupby(lab).sum().values
array([[  0,   0,   0,   0],
       [ 13,   2,   0,  11],
       [110,   7,   5, 117],
       [  0,   0,   0,   0]])

What you may be looking for is xarray.

From its documentation:

xarray: N-D labeled arrays and datasets in Python

xarray (formerly xray) is an open source project and Python package that makes working with labelled multi-dimensional arrays simple, efficient, and fun!

Xarray introduces labels in the form of dimensions, coordinates and attributes on top of raw NumPy-like arrays, which allows for a more intuitive, more concise, and less error-prone developer experience. The package includes a large and growing library of domain-agnostic functions for advanced analytics and visualization with these data structures.

Xarray was inspired by and borrows heavily from pandas, the popular data analysis package focused on labelled tabular data. It is particularly tailored to working with netCDF files, which were the source of xarray’s data model, and integrates tightly with dask for parallel computing.

NumPy arrays are homogeneous. You have to set type for label array

import numpy as np
arr=np.linspace(0,1,11)
lbl=np.empty((arr.shape), dtype=object)
lbl[arr<.25]='a'
lbl[(arr>=.25) & (arr <=.75)] = 'b'
lbl[arr>.75]='c'

print arr
print lbl

Output:

[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1. ]
['a' 'a' 'a' 'b' 'b' 'b' 'b' 'b' 'c' 'c' 'c']

With pandas.DataFrame.to_csv you can write the columns and the index to a file:

import numpy as np
import pandas as pd

A = np.random.randint(0, 10, size=36).reshape(6, 6)
names = [_ for _ in 'abcdef']
df = pd.DataFrame(A, index=names, columns=names)
df.to_csv('df.csv', index=True, header=True, sep=' ')

will give you the following df.csv file:

  a b c d e f 
a 1 5 5 0 4 4 
b 2 7 5 4 0 9 
c 6 5 6 9 7 0 
d 4 3 7 9 9 3 
e 8 1 5 1 9 0 
f 2 8 0 0 5 1    

There are many ways of doing this. Here are a few options:

In [1]: import numpy

In [2]: x = numpy.array([5,6,7,8,10,11,12,14])

In [3]: x
Out[3]: array([ 5,  6,  7,  8, 10, 11, 12, 14])

In [4]: x > 10
Out[4]: array([False, False, False, False, False,  True,  True,  True], dtype=bool)

In [5]: ['Y' if y > 10 else 'N' for y in x]
Out[5]: ['N', 'N', 'N', 'N', 'N', 'Y', 'Y', 'Y']

In [6]: [{True: 'Y', False: 'N'}[y] for y in x > 10]
Out[6]: ['N', 'N', 'N', 'N', 'N', 'Y', 'Y', 'Y']

You could also use map or something of course :)

Note: OP's intervals are [-3,-1], [0,3] & (3,..), so I am only assuming integral values. The conditions can be altered accordingly, but the design remains.

Using list comprehensions for if-elif-else:

my_list = [-3,-2,-1,0,1,2,3,4,5,6]

my_list_mapping = ['F' if ((i >= -3) & (i <= -1)) else 'M' if ((i >= 0) & (i <= 3)) else 'S' for i in my_list]
print(my_list_mapping)
    ['F', 'F', 'F', 'M', 'M', 'M', 'M', 'S', 'S', 'S']

You are using the sparse_categorical_crossentropy loss, which takes integer labels (not one-hot encoded ones), while your labels are one-hot encoded. This is why you get an error.

The easiest way to fix it is to change loss to categorical_crossentropy.

Use np.stack instead of np.concatenate and everything should work:

train_array = np.stack((array_a,array_b,array_c,array_d,array_e,array_f,array_g,array_h), axis=0)
print(train_array.shape)
# (8, 300, 300)