Memory-mapped arrays for large data in NumPy

Introduction

Memory-mapped arrays let you work with very big data files without loading everything into memory. This helps when your data is too large to fit in your computer's RAM.

You have a huge dataset saved on disk and want to analyze parts of it without loading all at once.

You want to share large data between programs without copying it into memory multiple times.

You need to process data that is bigger than your computer's available RAM.

You want faster access to parts of a large file without reading the entire file.

You want to save memory when working with large arrays in scientific computing.

Syntax

NumPy

import numpy as np

# Create or load a memory-mapped array
memmap_array = np.memmap(filename, dtype=data_type, mode='r+', shape=(rows, columns))

filename is the path to the file on disk.

dtype is the data type of the array elements (e.g., np.float64).

mode can be 'r' (read-only), 'r+' (read-write), 'w+' (create or overwrite), or 'c' (copy-on-write).

shape defines the dimensions of the array.

Examples

This creates a new 1000x1000 array on disk filled with zeros.

NumPy

import numpy as np

# Example 1: Create a new memory-mapped array file
memmap_array = np.memmap('data.dat', dtype=np.float64, mode='w+', shape=(1000, 1000))
memmap_array[:] = 0  # Initialize with zeros
memmap_array.flush()  # Save changes to disk

This opens the existing file without allowing changes.

NumPy

import numpy as np

# Example 2: Load an existing memory-mapped array in read-only mode
memmap_array = np.memmap('data.dat', dtype=np.float64, mode='r', shape=(1000, 1000))
print(memmap_array[0, 0])

Trying to open a non-existing file in read-write mode causes an error.

NumPy

import numpy as np

# Example 3: Edge case - file does not exist with mode='r+'
try:
    memmap_array = np.memmap('missing.dat', dtype=np.float64, mode='r+', shape=(10, 10))
except FileNotFoundError as error:
    print('File not found:', error)

Memory-mapped array with only one element works fine.

NumPy

import numpy as np

# Example 4: Edge case - single element array
memmap_array = np.memmap('single_element.dat', dtype=np.int32, mode='w+', shape=(1,))
memmap_array[0] = 42
memmap_array.flush()
print(memmap_array[0])

Sample Program

This program creates a large memory-mapped array file, initializes it, modifies a small block, and then reads it back in read-only mode to confirm the changes.

NumPy

import numpy as np
import os

filename = 'large_data.dat'

# Step 1: Create a large memory-mapped array file (100x100) filled with zeros
if os.path.exists(filename):
    os.remove(filename)  # Remove if exists to start fresh

large_memmap = np.memmap(filename, dtype=np.float64, mode='w+', shape=(100, 100))
large_memmap[:] = 0
large_memmap.flush()

print('Initial sum of all elements:', large_memmap.sum())

# Step 2: Modify a small part of the array
large_memmap[10:15, 10:15] = 5.5
large_memmap.flush()

print('Sum after modification:', large_memmap.sum())

# Step 3: Load the same file in read-only mode and check values
loaded_memmap = np.memmap(filename, dtype=np.float64, mode='r', shape=(100, 100))
print('Value at (12, 12):', loaded_memmap[12, 12])
print('Sum from loaded array:', loaded_memmap.sum())

Important Notes

Time complexity: Accessing or modifying elements is fast and similar to normal arrays, but initial file creation depends on file size.

Space complexity: Uses disk space equal to the array size; RAM usage is low because data is loaded on demand.

Common mistake: Forgetting to call flush() to save changes to disk when using write modes.

Use memory-mapped arrays when data is too large for RAM. For small data, normal numpy arrays are simpler and faster.

Summary

Memory-mapped arrays let you work with large data files without loading all data into memory.

They behave like normal numpy arrays but store data on disk, saving RAM.

Remember to flush changes to save them, and handle file existence carefully.

Practice

1. What is the main advantage of using numpy.memmap for large data files?

easy

A. It allows working with data without loading the entire file into memory.

B. It compresses the data to save disk space.

C. It automatically cleans up unused files.

D. It speeds up CPU calculations by using GPU.

Solution

1. Step 1: Understand memory usage with large files

   Loading large files fully into RAM can cause memory errors or slowdowns.

2. Step 2: Role of numpy.memmap

   Memory-mapped arrays let you access parts of the file on disk as if they were in memory, avoiding full loading.

3. Final Answer:

   It allows working with data without loading the entire file into memory. -> Option A

4. Quick Check:

   Memory-mapping = Partial loading [OK]

Hint: Memory-mapping means partial file loading, not full load [OK]

Common Mistakes:

• Thinking memmap compresses data
• Assuming memmap speeds up CPU/GPU
• Believing memmap auto-deletes files

2. Which of the following is the correct way to create a memory-mapped array from a file named data.dat with shape (100, 100) and dtype float64?

easy

A. np.memmap('data.dat', shape=(100, 100), dtype='int32', mode='w+')

B. np.memmap('data.dat', dtype='float64', mode='r+', shape=(100, 100))

C. np.memmap('data.dat', dtype='float64', shape=(100, 100))

D. np.memmap('data.dat', mode='r', shape=(100, 100), dtype='float32')

Solution

1. Step 1: Check required parameters for memmap

   Must specify filename, dtype, mode, and shape for memmap creation.

2. Step 2: Validate each option

   np.memmap('data.dat', dtype='float64', mode='r+', shape=(100, 100)) correctly uses dtype='float64', mode='r+', and shape=(100, 100). Others have wrong dtype or missing mode.

3. Final Answer:

   np.memmap('data.dat', dtype='float64', mode='r+', shape=(100, 100)) -> Option B

4. Quick Check:

   Correct dtype, mode, shape = np.memmap('data.dat', dtype='float64', mode='r+', shape=(100, 100)) [OK]

Hint: Always specify dtype, mode, and shape explicitly [OK]

Common Mistakes:

• Omitting mode parameter
• Using wrong dtype
• Swapping dtype and shape order

3. Given the code below, what will be the output of print(mm[0, 0])?

import numpy as np
filename = 'test.dat'
mm = np.memmap(filename, dtype='int32', mode='w+', shape=(2, 2))
mm[0, 0] = 10
mm.flush()
mm2 = np.memmap(filename, dtype='int32', mode='r', shape=(2, 2))
print(mm2[0, 0])

medium

A. Raises an error

B. 0

C. 10

D. Uninitialized garbage value

Solution

1. Step 1: Write value and flush to disk

   Value 10 is assigned to mm[0,0] and flushed, saving to file.

2. Step 2: Read from file with new memmap

   mm2 reads the same file in read mode, so mm2[0,0] is 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Flush saves data, read memmap shows 10 [OK]

Hint: Flush saves changes; reading memmap shows updated value [OK]

Common Mistakes:

• Forgetting to flush before reading
• Expecting zero without initialization
• Confusing write and read modes

4. What is the error in the following code snippet?

import numpy as np
filename = 'data.dat'
mm = np.memmap(filename, dtype='float64', mode='r+', shape=(3, 3))
mm[0, 0] = 5.0
mm.flush()

Assume data.dat does not exist before running this code.

medium

A. No error; code runs fine.

B. TypeError due to wrong dtype.

C. ValueError because shape is incorrect.

D. FileNotFoundError because mode 'r+' requires existing file.

Solution

1. Step 1: Understand mode 'r+'

   Mode 'r+' opens file for reading and writing but requires the file to exist.

2. Step 2: Check file existence

   Since 'data.dat' does not exist, opening with 'r+' raises FileNotFoundError.

3. Final Answer:

   FileNotFoundError because mode 'r+' requires existing file. -> Option D

4. Quick Check:

   Mode 'r+' needs existing file [OK]

Hint: Mode 'r+' needs existing file; else FileNotFoundError [OK]

Common Mistakes:

• Assuming 'r+' creates file
• Confusing 'r+' with 'w+'
• Ignoring file existence requirement

5. You have a large dataset stored in a binary file large_data.dat with shape (10000, 10000) and dtype float32. You want to increment all values by 1 without loading the entire file into memory. Which approach using numpy.memmap is best?

hard

A. Create a memmap with mode 'r+', loop over rows, increment each row, flush after each.

B. Load entire file with np.fromfile, add 1, then save back.

C. Open memmap with mode 'w+', increment only first 100 elements, flush once.

D. Use memmap with mode 'r', add 1 to the array, then flush.

Solution

1. Step 1: Avoid loading entire file

   Loading full 10000x10000 array uses too much RAM, so avoid np.fromfile full load.

2. Step 2: Use memmap with mode 'r+' and process in chunks

   Memmap with 'r+' allows read/write access. Looping over rows increments data without full load. Flushing saves changes.

3. Step 3: Evaluate other options

   Load entire file with np.fromfile, add 1, then save back. loads full file (bad for memory). Open memmap with mode 'w+', increment only first 100 elements, flush once. only increments part of data. Use memmap with mode 'r', add 1 to the array, then flush. uses 'r' mode (read-only), so cannot modify.

4. Final Answer:

   Create a memmap with mode 'r+', loop over rows, increment each row, flush after each. -> Option A

5. Quick Check:

   Memmap + chunk update + flush = Create a memmap with mode 'r+', loop over rows, increment each row, flush after each. [OK]

Hint: Use memmap with 'r+' and update in chunks to save memory [OK]

Common Mistakes:

• Loading entire file into memory
• Using read-only mode for writing
• Modifying only part of data