Monitoring memory usage in NumPy - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of monitoring memory usage in a program?

Monitoring memory usage helps to understand how much memory a program consumes, which can prevent crashes and improve performance by avoiding memory leaks or excessive consumption.

beginner

Which Python module can be used to check the memory size of a numpy array?

The nbytes attribute of a numpy array shows the total bytes consumed by the array's elements.

beginner

How do you get the memory size of a numpy array named arr?

Use arr.nbytes to get the total memory in bytes used by the array data.

intermediate

What does the sys.getsizeof() function do in Python?

It returns the size in bytes of a Python object, including overhead, but for numpy arrays it does not include the data buffer size, so nbytes is preferred for arrays.

intermediate

Why is it important to monitor memory usage when working with large numpy arrays?

Large numpy arrays can consume a lot of memory, which may slow down the system or cause crashes. Monitoring helps optimize memory use and avoid running out of memory.

Which numpy attribute gives the total bytes used by the array data?

A nbytes

B size

C shape

D dtype

The nbytes attribute returns the total number of bytes consumed by the elements of the array.

What does sys.getsizeof() NOT include for numpy arrays?

A The size of small integers

B The object overhead

C The size of Python objects

D The data buffer size

sys.getsizeof() does not include the memory used by the actual data buffer of numpy arrays.

Why monitor memory usage in numpy programs?

A To increase CPU speed

B To avoid memory leaks and crashes

C To change array shapes automatically

D To reduce disk space usage

Monitoring memory helps prevent leaks and crashes by managing how much memory numpy arrays consume.

Which of these is NOT a reason to monitor memory usage?

A Automatically fix bugs in code

B Avoid running out of memory

C Prevent system slowdowns

D Optimize resource use

Monitoring memory usage helps manage resources but does not automatically fix bugs.

If you want to check how many bytes a numpy array uses, which is the best method?

A Use <code>sys.getsizeof(arr)</code>

B Use <code>len(arr)</code>

C Use <code>arr.nbytes</code>

D Use <code>arr.shape</code>

arr.nbytes gives the exact number of bytes used by the array data.

Explain how to monitor memory usage of a numpy array and why it is important.

Think about how numpy stores data and what happens if memory is too large.

Describe the difference between sys.getsizeof() and nbytes when checking memory usage of numpy arrays.

Consider what each function measures in Python objects vs numpy arrays.

Practice

1. What does the nbytes attribute of a NumPy array represent?

easy

A. The size of each element in the array

B. The total memory in bytes used by the array data

C. The number of elements in the array

D. The number of dimensions of the array

Solution

1. Step 1: Understand what nbytes means

   The nbytes attribute gives the total number of bytes consumed by the elements of the array.

2. Step 2: Differentiate from other attributes

   Other attributes like size give element count, itemsize gives size per element, and ndim gives dimensions.

3. Final Answer:

   The total memory in bytes used by the array data -> Option B

4. Quick Check:

   nbytes = total bytes used [OK]

Hint: Remember: nbytes = total bytes used by array data [OK]

Common Mistakes:

• Confusing nbytes with size (number of elements)
• Thinking nbytes is size of one element
• Mixing nbytes with number of dimensions

2. Which of the following is the correct way to get the memory usage of a NumPy array arr?

easy

A. arr.memsize

B. arr.memory()

C. arr.size()

D. arr.nbytes

Solution

1. Step 1: Recall the attribute for memory usage

   The correct attribute to get total memory used by array data is nbytes, accessed without parentheses.

2. Step 2: Check other options for correctness

   memory() and memsize do not exist; size() is a method but returns element count, not memory.

3. Final Answer:

   arr.nbytes -> Option D

4. Quick Check:

   Use nbytes attribute, no parentheses [OK]

Hint: Use arr.nbytes without parentheses to get memory [OK]

Common Mistakes:

• Using parentheses with nbytes (it's an attribute, not a method)
• Confusing size() method with memory usage
• Trying non-existent methods like memory()

3. What is the output of the following code?

import numpy as np
arr = np.array([1, 2, 3, 4], dtype=np.int32)
print(arr.nbytes)

medium

A. 8

B. 32

C. 16

D. 4

Solution

1. Step 1: Calculate number of elements and size per element

   The array has 4 elements, each of type int32 which uses 4 bytes.

2. Step 2: Multiply elements by bytes per element

   Total bytes = 4 elements * 4 bytes = 16 bytes.

3. Final Answer:

   16 -> Option C

4. Quick Check:

   4 elements x 4 bytes = 16 bytes [OK]

Hint: Multiply element count by itemsize for nbytes [OK]

Common Mistakes:

• Assuming int32 uses 8 bytes
• Confusing nbytes with number of elements
• Forgetting to multiply by element size

4. You run this code but get an error:

import numpy as np
arr = np.array([1, 2, 3])
print(arr.nbytes())

What is the cause of the error?

medium

A. nbytes is an attribute, not a method; remove parentheses

B. Array must be created with dtype specified

C. nbytes only works on 2D arrays

D. You must import nbytes separately

Solution

1. Step 1: Identify the error cause

   The code calls arr.nbytes() with parentheses, but nbytes is an attribute, not a function.

2. Step 2: Correct usage

   Access nbytes without parentheses: arr.nbytes.

3. Final Answer:

   nbytes is an attribute, not a method; remove parentheses -> Option A

4. Quick Check:

   Attributes have no parentheses [OK]

Hint: Remember: attributes like nbytes have no parentheses [OK]

Common Mistakes:

• Adding parentheses to attributes
• Thinking dtype is required for nbytes
• Believing nbytes only works on certain array shapes

5. You have a large NumPy array big_arr with 1 million elements of type float64. You want to reduce memory usage without losing much precision. Which approach helps monitor and reduce memory usage effectively?

hard

A. Check big_arr.nbytes and convert to float32 if memory is high

B. Use big_arr.size to reduce elements by half

C. Delete big_arr and recreate with zeros

D. Convert big_arr to Python list to save memory

Solution

1. Step 1: Monitor memory usage with nbytes

   Use big_arr.nbytes to see current memory consumption in bytes.

2. Step 2: Reduce memory by changing data type

   Converting from float64 (8 bytes) to float32 (4 bytes) halves memory usage with minimal precision loss.

3. Final Answer:

   Check big_arr.nbytes and convert to float32 if memory is high -> Option A

4. Quick Check:

   Use nbytes + dtype change to reduce memory [OK]

Hint: Check nbytes then downcast dtype to save memory [OK]

Common Mistakes:

• Using size instead of nbytes to measure memory
• Converting to Python list increases memory
• Deleting array without monitoring memory