x is a 2D array, which can also be looked upon as an array of 1D arrays, having 10 rows and 1024 columns. x[0] is the first 1D sub-array which has 1024 elements (there are 10 such 1D sub-arrays in x), and x[0].shape gives the shape of that sub-array, which happens to be a 1-tuple - (1024, ).

On the other hand, x.shape is a 2-tuple which represents the shape of x, which in this case is (10, 1024). x.shape[0] gives the first element in that tuple, which is 10.

Here's a demo with some smaller numbers, which should hopefully be easier to understand.

x = np.arange(36).reshape(-1, 9)
x

array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8],
       [ 9, 10, 11, 12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23, 24, 25, 26],
       [27, 28, 29, 30, 31, 32, 33, 34, 35]])

x[0]
array([0, 1, 2, 3, 4, 5, 6, 7, 8])

x[0].shape
(9,)

x.shape
(4, 9)

x.shape[0]
4

From your error message:

"TypeError: arange: scalar arguments expected instead of a tuple."

It sounds to me like you are trying to use the shape of an existing array to define the shape of a new array using np.arange.

Your problem is that you don't understand what x.shape is giving you.

For example:

x = np.array([[1,2,3],[4,5,6]])
x.shape

produces (2,3), a tuple. If I try to use just x.shape to define a argument in np.arange like this:

np.arange(x.shape)

I get the following error:

"arange: scalar arguments expected instead of a tuple."

Reason being np.arange accepts either a scalar (which creates an array starting at 0 and increasing by 1 to the length provided) or 3 scalars which define where to start and end the array and the step size. You are giving it a tuple instead which it doesn't like.

So when you do:

np.arange(x.shape[0])

you are giving the arange function the first scalar in the tuple provided by x.shape and in my example producing an array like this [0,1] because the first index in the tuple is 2.

If I alternatively did

np.arange(x.shape[1])

I would get an array like [0,1,2] because the second index in the tuple is a 3.

If I did any of the following,

np.arange(x.shape[2])
np.arange(x.shape[1000])
np.arange(x.shape[300])

I would get an error because the tuple created by x.shape has only two dimensions and so can't be indexed any further than 0 or 1.

Hope that helps!

The shape attribute for numpy arrays returns the dimensions of the array. If Y has n rows and m columns, then Y.shape is (n,m). So Y.shape[0] is n.

In [46]: Y = np.arange(12).reshape(3,4)

In [47]: Y
Out[47]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [48]: Y.shape
Out[48]: (3, 4)

In [49]: Y.shape[0]
Out[49]: 3

array.shape and np.shape(array) are the same:

See on Numpy Docs

This is quite common in computer vision the first dimension being the number of examples, the second and third provide the data of the examples. In the case of computer vision for example it is quite common to have a set of n images with shape (x,y). In this case your training set will be of the shape (n,x,y). The fourth dimension in your data is the number of channels (3, or RGB in this case).

In your dataset the height and the width of each image is the same and thus the size of the image can be retrieved merely by the third line: num_px = train_set_x_orig.shape[1]