When NumPy is not fast enough - Mini Project: Build & Apply

When NumPy is not fast enough

📖 Scenario: You are working with large numerical datasets using NumPy. Sometimes, NumPy operations can be slow for very large or complex computations. To speed things up, you want to try a faster alternative using numba, a tool that can compile Python code to machine code.This project will guide you through creating a NumPy array, setting a threshold, writing a function with numba to speed up calculations, and comparing the results.

🎯 Goal: Build a small program that creates a NumPy array, sets a threshold value, uses numba to speed up a calculation that counts how many elements are above the threshold, and prints the result.

📋 What You'll Learn

Create a NumPy array with specific values

Set a threshold variable

Write a function using numba to count elements above the threshold

Print the count result

💡 Why This Matters

🌍 Real World

In data science, sometimes NumPy alone is not fast enough for complex or large computations. Using tools like numba can speed up your code by compiling Python functions to machine code.

💼 Career

Knowing how to optimize numerical computations with numba is valuable for data scientists and engineers working with large datasets or performance-critical applications.

1

Create the NumPy array

Import numpy as np and create a NumPy array called data with these exact values: [1, 5, 8, 12, 20, 3, 7].

NumPy

# Import numpy as np and create the array data
# Your code here

Hint

Use np.array([...]) to create the array.

2

Set the threshold value

Create a variable called threshold and set it to the integer 7.

NumPy

import numpy as np

data = np.array([1, 5, 8, 12, 20, 3, 7])

# Create the threshold variable and set it to 7
# Your code here

Hint

Just assign the number 7 to threshold.

3

Write a numba-accelerated function

Import njit from numba. Then write a function called count_above_threshold that takes two arguments: arr and thresh. Use a for loop to count how many elements in arr are greater than thresh. Decorate the function with @njit.

NumPy

import numpy as np
from numba import njit

data = np.array([1, 5, 8, 12, 20, 3, 7])

threshold = 7

# Write the @njit decorated function count_above_threshold(arr, thresh)
# Your code here

Hint

Use @njit above the function. Inside, loop over arr and count elements greater than thresh.

4

Print the count result

Call the function count_above_threshold with data and threshold as arguments. Print the returned count.

NumPy

import numpy as np
from numba import njit

data = np.array([1, 5, 8, 12, 20, 3, 7])

threshold = 7

@njit
def count_above_threshold(arr, thresh):
    count = 0
    for x in arr:
        if x > thresh:
            count += 1
    return count

# Call count_above_threshold with data and threshold, then print the result
# Your code here

Hint

Use print(count_above_threshold(data, threshold)) or assign to a variable first.

Practice

1. Why might NumPy sometimes be too slow for certain tasks?

easy

A. Because it does not support mathematical operations

B. Because it cannot handle arrays larger than 100 elements

C. Because it only works on single-core processors

D. Because it uses Python loops internally which are slow

Solution

1. Step 1: Understand NumPy's speed basis

   NumPy is fast because it uses optimized C code, but Python loops around NumPy operations can slow it down.

2. Step 2: Identify the cause of slowness

   When complex tasks require Python loops or non-vectorized code, speed drops because Python loops are slower than compiled code.

3. Final Answer:

   Because it uses Python loops internally which are slow -> Option D

4. Quick Check:

   Python loops slow NumPy = Because it uses Python loops internally which are slow [OK]

Hint: NumPy is fast with vectorized code, slow with Python loops [OK]

Common Mistakes:

• Thinking NumPy can't handle large arrays
• Believing NumPy only works on single-core CPUs
• Assuming NumPy lacks math operation support

2. Which of the following is the correct way to import Numba to speed up NumPy code?

easy

A. import numba as nb

B. import numba.speedup

C. from numba import jit

D. import numba.jit

Solution

1. Step 1: Recall Numba import syntax

   Numba's just-in-time compiler is accessed by importing jit from numba: from numba import jit.

2. Step 2: Check other options

   Options A, C, and D are invalid imports; 'import numba as nb' imports the whole module but requires nb.jit to use the decorator, while C and D do not exist.

3. Final Answer:

   from numba import jit -> Option C

4. Quick Check:

   Correct Numba import = from numba import jit [OK]

Hint: Use 'from numba import jit' to access speedup decorator [OK]

Common Mistakes:

• Trying to import submodules that don't exist
• Importing whole numba without jit
• Using incorrect import syntax

3. What will be the output of this code snippet?

import numpy as np
from numba import jit

@jit(nopython=True)
def sum_squares(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

print(sum_squares(5))

medium

A. 30

B. 55

C. 10

D. Error due to jit decorator

Solution

1. Step 1: Understand the function logic

   The function sums squares of numbers from 0 to n-1. For n=5, it sums 0²+1²+2²+3²+4² = 0+1+4+9+16 = 30.

2. Step 2: Check jit decorator effect

   The jit decorator speeds up the function but does not change output. No error occurs.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Sum of squares 0 to 4 = 30 [OK]

Hint: Sum squares 0 to 4 = 30; jit doesn't change output [OK]

Common Mistakes:

• Confusing sum of squares with sum of numbers
• Expecting jit to cause errors
• Miscounting range end

4. Identify the error in this code that tries to speed up a NumPy operation using Numba:

import numpy as np
from numba import jit

@jit
def multiply_array(arr):
    return arr * 2

print(multiply_array(np.array([1, 2, 3])))

medium

A. Numba jit cannot speed up NumPy array operations directly

B. The jit decorator is missing parentheses

C. The function multiply_array must use a loop inside

D. NumPy arrays cannot be passed to jit functions

Solution

1. Step 1: Understand Numba's limitations

   Numba jit speeds up Python loops and scalar operations but does not speed up vectorized NumPy operations directly.

2. Step 2: Analyze the code behavior

   The function returns arr * 2, which is a NumPy vectorized operation. Numba jit won't speed this up; it just calls NumPy internally.

3. Final Answer:

   Numba jit cannot speed up NumPy array operations directly -> Option A

4. Quick Check:

   Numba jit doesn't speed vectorized NumPy ops = Numba jit cannot speed up NumPy array operations directly [OK]

Hint: Numba jit speeds loops, not vectorized NumPy ops [OK]

Common Mistakes:

• Thinking jit decorator syntax is wrong
• Believing jit requires loops inside
• Assuming NumPy arrays can't be used with jit

5. You have a large NumPy array and want to speed up a custom function that applies a complex calculation element-wise. Which approach is best?

hard

A. Use pure Python loops without any acceleration

B. Rewrite the function using Numba jit with a loop over array elements

C. Convert the array to a list and use list comprehensions

D. Use NumPy vectorized operations only, no jit

Solution

1. Step 1: Understand the problem context

   Complex element-wise calculations may not be vectorizable easily with NumPy, so pure vectorized operations might not work.

2. Step 2: Choose the best speedup method

   Using Numba jit with a loop over array elements compiles the loop to fast machine code, speeding up the custom calculation.

3. Step 3: Evaluate other options

   Pure Python loops and list comprehensions are slow; vectorized NumPy ops may not support complex logic.

4. Final Answer:

   Rewrite the function using Numba jit with a loop over array elements -> Option B

5. Quick Check:

   Numba jit + loops = best speedup for complex element-wise ops [OK]

Hint: Use Numba jit with loops for complex element-wise speedup [OK]

Common Mistakes:

• Relying on pure Python loops for speed
• Converting arrays to lists unnecessarily
• Assuming all complex ops can be vectorized