Some important attributes of the ndarray object:
- ndarray.dtype provides the data type of the elments in the array
- ndarray.ndim tells us the number of axes (dimensions) in the array. For example. ndim will be 3 for a 3-dimensional array
- ndarray.shape represents the size of the array in its dimensions in the form of a tuple of integers
- ndarray.size is the number of elements in the whole array

NumPy ndarray attributes

When multiplying n-dimensional arrays it's important to know what type of multiplication you want to do. 
- When you want to do element-wise multiplication np.multiply() works the same way as using the * operator
- However, sometimes you want to take the dot product of two arrays, in which case you should use np.dot()
- The final common way to multiply n-dimensional arrays is by using np.mmult() which will return the matrix product of the arrays

NumPy Multiplication

When doing calculations using n-dimensional arrays you don't always need to initialize all elements to the same size, there are certain situations where python will broadcast the value into an array of the appropriate size.
For example, if I want to add 20 to every element in my array I can just write
```
new_array = old_array + 20
```
and python will automatically create an appropriately sized array where all elements are equal to 100

For the complete list of broadcasting possibilities, see the reference link

Broadcasting in array computations

Converting a deep learning tensor to a NumPy array (`ndarray`), or vice versa, is straightforward but involves framework-specific memory management behaviors. In PyTorch, the converted objects share the same underlying memory (e.g., via `X.numpy()` and `torch.from_numpy()`), meaning an in-place modification to one affects the other. Conversely, in frameworks like TensorFlow (via `X.numpy()` and `tf.constant()`), MXNet (via `X.asnumpy()` and `np.array()`), and JAX (via `jax.device_get()` and `jax.device_put()`), the converted result does not share memory. This isolation prevents the CPU or GPU from halting computations while waiting for Python's NumPy package to interact with the shared memory chunk.

Tensor to NumPy Array Conversion

The n-dimensional array, or ndarray, is the main data structure enabled by the NumPy library. It can be one- or multi-dimensional depending on the parameters passed to np.array(), but it must consist of homogenous (same-type) data. To create a 1D array, pass in a single list of objects, e.g. 

```np.array([1, 2, 3])```. 

To create a 2D array, pass in a list of lists, e.g. 

```np.array([[1, 2, 3], [4, 5, 6]]).```

University of Michigan - Ann Arbor

NumPy, which stands for Numerical Python, is a Python library that contains n-dimensional arrays and tools for processing those arrays.

NumPy

Python Documentation

NumPy n-dimensional array

* np.array() convert python array to ndarray
```python
 li = [1,2,3,4,5,6]
arr = np.array(li)     # convert to nd array
 display(arr)
```

* np.arange() Similar to python range, but returns an ndarray type.
```python
 np.arange(1,7)  
array([1, 2, 3, 4, 5, 6])
```
* np.zeros(), np.full(), np.eye() basic matrix creation methods.
```python
> np.zeros((2,3))
array([[0., 0.],
       [0., 0.],
       [0., 0.]])

> np.full((2,3), 55)  # 2 and 3 represents the dimensions, 55 representing the element.
array([[55, 55, 55],
       [55, 55, 55]])

> np.eye(2)   # diagonally filling the inputted parameter
array([[1., 0.],
        0., 1.])
```

Learn Before

Related

Learn After