Profiling NumPy operations - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the module used for profiling NumPy operations.

NumPy

import [1]

Drag options to blanks, or click blank then click option'

Amatplotlib

Bpandas

CcProfile

Dtimeit

Attempts:

3 left

💡 Hint

Common Mistakes

Importing unrelated modules like pandas or matplotlib.

Using timeit instead of cProfile for detailed profiling.

The cProfile module is used to profile Python code, including NumPy operations.

2fill in blank

medium

Complete the code to start profiling a function named compute_array.

NumPy

profiler = cProfile.Profile()
profiler.[1]('compute_array()')
profiler.print_stats()

Drag options to blanks, or click blank then click option'

Arun

Brunctx

Cenable

Ddisable

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'enable' or 'disable' instead of 'run'.

Using 'runctx' which requires extra context parameters.

The run method runs the function under the profiler.

3fill in blank

hard

Fix the error in the code to measure execution time of a NumPy operation using timeit.

NumPy

import numpy as np
import timeit

arr = np.arange(1000)
time = timeit.timeit(lambda: np.[1](arr), number=1000)
print(time)

Drag options to blanks, or click blank then click option'

Aappend

Bsort

Cadd

Dsum

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'add' which requires two arrays.

Using 'append' which is not a NumPy function.

Using 'sort' which is a method, not a function.

The sum function correctly computes the sum of array elements. add is a ufunc needing two arrays, append is not a NumPy function, and sort is a method, not a function.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that profiles functions with timeit and filters results greater than 0.001 seconds.

NumPy

functions = [np.sum, np.mean, np.std]
results = {func.__name__: timeit.timeit(lambda: func(np.arange(1000)), number=1000) for func in functions if [1] [2] 0.001}

Drag options to blanks, or click blank then click option'

Atimeit.timeit(lambda: func(np.arange(1000)), number=1000)

B>

C<

Dfunc.__name__

Attempts:

3 left

💡 Hint

Common Mistakes

Using function name instead of timing expression in the first blank.

Using '<' instead of '>' for filtering.

The comprehension measures time for each function and filters those with time greater than 0.001 seconds.

5fill in blank

hard

Fill all three blanks to create a profiling dictionary that stores function names, their execution times, and filters times less than 0.005 seconds.

NumPy

functions = [np.min, np.max, np.median]
profile = [1]: [2] for func in functions if [3] < 0.005

Drag options to blanks, or click blank then click option'

Afunc.__name__

Btimeit.timeit(lambda: func(np.arange(1000)), number=1000)

Dfunc

Attempts:

3 left

💡 Hint

Common Mistakes

Using function object instead of function name as key.

Using function object instead of timing expression for value or condition.

Mixing up the order of keys and values.

The dictionary comprehension keys are function names, values are execution times, and filtering is done on the execution time less than 0.005 seconds.

Practice

1. What is the main purpose of profiling NumPy operations?

easy

A. To make the code look cleaner

B. To find which parts of the code run slowly

C. To check if the code has syntax errors

D. To add comments to the code

Solution

1. Step 1: Understand profiling meaning

   Profiling means measuring how long parts of code take to run.

2. Step 2: Identify profiling goal in NumPy

   In NumPy, profiling helps find slow operations to improve speed.

3. Final Answer:

   To find which parts of the code run slowly -> Option B

4. Quick Check:

   Profiling = Find slow parts [OK]

Hint: Profiling = measuring speed to find slow code [OK]

Common Mistakes:

• Confusing profiling with debugging syntax errors
• Thinking profiling cleans code
• Assuming profiling adds comments

2. Which Python function is commonly used to measure time for profiling NumPy operations?

easy

A. time.time()

B. print()

C. len()

D. np.array()

Solution

1. Step 1: Recall timing functions in Python

   Python's time.time() returns current time in seconds.

2. Step 2: Use time.time() for profiling

   Subtracting start and end time.time() gives elapsed time.

3. Final Answer:

   time.time() -> Option A

4. Quick Check:

   Timing = time.time() [OK]

Hint: Use time.time() to get current time in seconds [OK]

Common Mistakes:

• Using print() to measure time
• Confusing len() with timing
• Using np.array() instead of timing

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

import numpy as np
import time
arr = np.arange(1000000)
start = time.time()
sum_val = np.sum(arr)
end = time.time()
print(round(end - start, 4))

medium

A. A very small number close to 0, like 0.001

B. The sum of numbers from 0 to 999999

C. An error because np.sum is wrong

D. The time in seconds as a large number like 1000

Solution

1. Step 1: Understand code timing

   The code measures time to sum 1 million numbers using np.sum.

2. Step 2: Expect timing output

   np.sum is fast; timing will be a small float near zero seconds.

3. Final Answer:

   A very small number close to 0, like 0.001 -> Option A

4. Quick Check:

   Timing output = small float [OK]

Hint: np.sum is fast; timing shows small seconds [OK]

Common Mistakes:

• Thinking output is the sum value
• Expecting an error from np.sum
• Assuming timing is very large

4. Identify the error in this profiling code:

import numpy as np
import time
arr = np.arange(1000)
start = time.time()
sum_val = np.sum(arr)
print(round(end - start, 5))
end = time.time()

medium

A. round() cannot take two arguments

B. np.sum does not work on arrays

C. time.time() cannot be used twice

D. Variable 'end' is used before assignment

Solution

1. Step 1: Check variable usage order

   The code prints end - start before end is assigned.

2. Step 2: Identify error cause

   This causes a NameError because end is undefined at print time.

3. Final Answer:

   Variable 'end' is used before assignment -> Option D

4. Quick Check:

   Use end after assignment [OK]

Hint: Assign end before using it in print [OK]

Common Mistakes:

• Thinking np.sum is invalid
• Believing time.time() can't be called twice
• Confusing round() arguments

5. You want to compare the speed of two NumPy operations on large arrays. Which approach is best for profiling?

hard

A. Run each operation once and compare times

B. Only check the code visually without timing

C. Run each operation many times and average the times

D. Use print statements inside the operations

Solution

1. Step 1: Understand timing variability

   Running once can give misleading times due to random delays.

2. Step 2: Use repeated runs for accuracy

   Running many times and averaging smooths out random noise.

3. Final Answer:

   Run each operation many times and average the times -> Option C

4. Quick Check:

   Average multiple runs for reliable timing [OK]

Hint: Average many runs to get stable timing [OK]

Common Mistakes:

• Trusting single run timing
• Ignoring timing and just reading code
• Using print instead of timing