Profiling NumPy operations - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of profiling NumPy operations?

Profiling NumPy operations helps identify which parts of the code take the most time or resources, so you can optimize performance.

beginner

Which Python module is commonly used to profile NumPy code performance?

The timeit module is commonly used to measure execution time of NumPy operations accurately.

beginner

How does the %timeit magic command in Jupyter notebooks help with profiling?

It runs the code multiple times and shows the average execution time, helping to get reliable timing for NumPy operations.

intermediate

What is the benefit of using vectorized NumPy operations over Python loops when profiling?

Vectorized operations run much faster because they use optimized C code internally, reducing execution time compared to Python loops.

intermediate

Name a tool that provides detailed profiling including CPU time and memory usage for NumPy code.

The cProfile module can profile CPU time, and tools like memory_profiler can track memory usage for NumPy operations.

Which method is best to measure the average execution time of a NumPy operation in a Jupyter notebook?

A %timeit

B print()

C input()

D len()

The %timeit magic command runs the code multiple times and reports the average execution time.

Why are vectorized NumPy operations faster than Python loops?

A They use optimized C code internally

B They run on the GPU automatically

C They use more memory

D They run slower but use less power

Vectorized operations use optimized C code inside NumPy, making them faster than Python loops.

Which Python module can profile CPU time for NumPy code?

A matplotlib

B pandas

C cProfile

D scipy

The cProfile module profiles CPU time and helps find slow parts of the code.

What does the timeit module measure?

A Network speed

B Execution time of code snippets

C Disk space

D Memory usage

The timeit module measures how long code takes to run.

Which tool helps measure memory usage of NumPy operations?

A matplotlib

B timeit

C numpy.linalg

D memory_profiler

memory_profiler tracks memory usage during code execution.

Explain how you would profile a NumPy operation to find performance bottlenecks.

Think about timing, CPU, and memory aspects.

Describe why vectorized operations in NumPy are preferred when optimizing code performance.

Focus on speed and internal implementation.

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