Profiling NumPy operations - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of timing a NumPy operation with %timeit

What is the output type when you run the following code in a Jupyter notebook cell?

import numpy as np
arr = np.random.rand(1000, 1000)
%timeit np.dot(arr, arr)

NumPy

import numpy as np
arr = np.random.rand(1000, 1000)
%timeit np.dot(arr, arr)

A It returns a NumPy array with the dot product result.

B It prints the average execution time of the dot product operation multiple times.

C It raises a SyntaxError because %timeit is invalid syntax in Python scripts.

D It returns the shape of the resulting array from the dot product.

💡 Hint

Remember that %timeit is a magic command in Jupyter to measure execution time.

The %timeit magic command runs the code multiple times and prints the average time taken. It does not return the result of the operation or any array.

❓ data_output

intermediate

Result of profiling a NumPy sum operation with time.perf_counter

What is the value of the variable duration after running this code?

import numpy as np
import time
arr = np.arange(1000000)
start = time.perf_counter()
s = np.sum(arr)
end = time.perf_counter()
duration = end - start
print(round(duration, 5))

NumPy

import numpy as np
import time
arr = np.arange(1000000)
start = time.perf_counter()
s = np.sum(arr)
end = time.perf_counter()
duration = end - start
print(round(duration, 5))

A A small float number representing seconds, typically less than 0.01.

B The sum of numbers from 0 to 999999, which is 499999500000.

C An integer representing the number of elements in the array, 1000000.

D A string showing the start and end times concatenated.

💡 Hint

The variable duration measures elapsed time, not the sum value.

duration is the difference between end and start times, so it is a small float showing how long np.sum took.

🔧 Debug

advanced

Identify the error in profiling a NumPy operation

What error will this code raise when run in a standard Python script (not Jupyter)?

import numpy as np
arr = np.random.rand(1000, 1000)
%timeit np.linalg.inv(arr)

NumPy

import numpy as np
arr = np.random.rand(1000, 1000)
%timeit np.linalg.inv(arr)

A TypeError because np.linalg.inv expects a 1D array.

B No error; it runs and prints timing information.

C SyntaxError: invalid syntax because %timeit is a Jupyter magic command.

D ValueError because the matrix is singular and cannot be inverted.

💡 Hint

Consider where %timeit commands are valid.

%timeit is a magic command only available in Jupyter or IPython environments, not in standard Python scripts.

🚀 Application

advanced

Choosing the best method to profile a NumPy function in a script

You want to measure how long a NumPy matrix multiplication takes inside a Python script (not Jupyter). Which method is best to get accurate timing?

Options:

NumPy

import numpy as np
import time
arr = np.random.rand(1000, 1000)

# Which timing method to use here?

A Use time.perf_counter() before and after the operation to measure elapsed time.

B Use %timeit magic command around the operation.

C Use print(time.time()) before and after, then subtract.

D Use np.profile() function to get timing.

💡 Hint

Magic commands like %timeit only work in Jupyter, and np.profile() does not exist.

time.perf_counter() provides high-resolution timing suitable for scripts. time.time() is less precise. %timeit is invalid outside Jupyter. np.profile() is not a real function.

🧠 Conceptual

expert

Understanding the impact of array size on NumPy operation profiling

You profile np.dot on arrays of increasing size and notice the time grows roughly with the cube of the dimension (n). Why does the time complexity behave like this for matrix multiplication?

A Because the arrays are stored inefficiently causing slow access.

B Because NumPy uses a recursive algorithm that doubles time each step.

C Because the time depends only on the number of rows, not columns.

D Because matrix multiplication involves n^3 scalar multiplications and additions.

💡 Hint

Think about how many operations are needed to multiply two n x n matrices.

Standard matrix multiplication requires n^3 operations: for each of n rows and n columns, n multiplications and additions happen.