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

University of Michigan - Ann Arbor

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]]).```

NumPy n-dimensional array

NumPy Documentation

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

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.

Learn Before

Related