Gain insights into utilizing NumPy for data manipulation and analytics. Learn about implementing concepts in both Python and NumPy through coding challenges and quizzes.

python.tar.gz

python3.6

Live3.6

If you're looking to grow your career in machine learning or data science in this day and age, adding a powerful library to your skill set is an important place to start. In that vein, Python has become one of the most widely used tools in the industry for serious data analytics, and NumPy is probably the most widely used data analytics library. With NumPy, you can manipulate data involving multi-dimensional arrays and matrices (think linear algebra).

Join us as we venture into the vast world of NumPy in this comprehensive course. Each lesson dive into the actual implementation of concepts in both pure Python and then NumPy, exploring how NumPy vectorization compares to traditional Python that uses a procedural and object-oriented approach.

Practice and test yourself along the way with in-browser coding challenges, quizzes, and more.

This course is intended for users who are already familiar with intermediate level Python.

From Python to Numpy

# NumPy Implementation
As you might expect, the NumPy implementation takes a different approach and we'll gather all our boids into a position array and a velocity array:

```
n = 500
velocity = np.zeros((n, 2), dtype=np.float32)
position = np.zeros((n, 2), dtype=np.float32)
```
The first step is to compute the local neighborhood for all boids, and for this, we need to compute all paired distances:

```python
#np.subtract.outer  apply the ufunc op to all pairs (a, b) with a in A and b in B.
dx = np.subtract.outer(position[:, 0], position[:, 0])
dy = np.subtract.outer(position[:, 1], position[:, 1])
distance = np.hypot(dx, dy)
```

$$$$
We could have used the `scipy` [cdist](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cdist.html) but we'll need the `dx` and `dy` arrays later. Once those have been computed, it is faster to use the [hypot](https://docs.scipy.org/doc/numpy/reference/generated/numpy.hypot.html) method. Note that distance shape is `(n, n)` and each line relates to one boid, i.e. each line gives the distance to all other boids (including self).

From these distances, we can now compute the local neighborhood for each of the three rules, taking advantage of the fact that we can mix them together. We can actually compute a mask for distances that are strictly positive (i.e. have no self-interaction) and multiply it with other distance masks.

> **Note:** If we suppose that boids cannot occupy the same position, how can you compute `mask_0` more efficiently?

$$$$
```
mask_0 = (distance > 0)
mask_1 = (distance < 25)
mask_2 = (distance < 50)
mask_1 *= mask_0
mask_2 *= mask_0
mask_3 = mask_2
```
Then, we compute the number of neighbors within the given radius and we ensure it is at least 1 to avoid division by zero.
```
mask_1_count = np.maximum(mask_1.sum(axis=1), 1)
mask_2_count = np.maximum(mask_2.sum(axis=1), 1)
mask_3_count = mask_2_count
```
We're ready to write our three rules:
$$$$
## Alignment


In this lesson we will try to implement all three rules that Boids follow using the NumPy approach. 

Introduction

Anatomy of an Array

Code Vectorization

Problem Vectorization

Custom Vectorization

Beyond NumPy

Conclusion

Coding Example: Implement the behavior of Boids (NumPy approach)

NumPy Implementation