Fix: NumPy Not Working — Broadcasting Error, dtype Mismatch, and Array Shape Problems

The Error

You add two arrays and NumPy refuses:

ValueError: operands could not be broadcast together with shapes (3,4) (3,)

Or you build an array from a list and get a cryptic type error:

ValueError: setting an array element with a sequence. The requested array has an inhomogeneous shape after N dimensions.

Or the math looks right but the numbers are wrong — an integer that should be large wraps to a negative number, or a modification to a slice doesn’t affect the original array like you expected.

Or you upgrade NumPy and existing code breaks:

AttributeError: module 'numpy' has no attribute 'bool'

NumPy is designed for vectorized operations over typed, fixed-shape arrays. When your data or expectations don’t match that model, these errors appear. This guide covers the root causes and fixes for each.

Why This Happens

NumPy stores data as contiguous blocks of memory with a fixed dtype and shape. Operations between arrays require compatible shapes — NumPy has strict rules about when and how it broadcasts smaller arrays to match larger ones. The dtype system is C-level (int32, float64), not Python-level (int, float), which means overflow is silent and type coercion follows rules Python developers don’t expect.

The view/copy system — where slicing returns a reference into the same memory rather than a new array — causes particularly subtle bugs because modifications can silently propagate (or silently not propagate) depending on how you index.

Fix 1: Broadcasting Error — Understanding Shape Alignment

ValueError: operands could not be broadcast together with shapes (3,4) (3,)

Broadcasting is how NumPy handles operations between arrays of different shapes. The rules:

1. If two arrays have different numbers of dimensions, pad the smaller shape on the left with 1s.
2. Along each dimension, sizes must be equal, or one of them must be 1 (which stretches to match the other).

import numpy as np

a = np.ones((3, 4))   # shape (3, 4)
b = np.ones((4,))     # shape (4,) → padded to (1, 4) → broadcasts to (3, 4) ✓

result = a + b        # Works: (3, 4) + (1, 4) → (3, 4)
print(result.shape)   # (3, 4)

The common failure: a shape (3,) is treated as (1, 3), not (3, 1). This means it can broadcast with axis 1 (columns), not axis 0 (rows):

a = np.ones((3, 4))   # shape (3, 4)
b = np.ones((3,))     # shape (3,) → padded to (1, 3) — columns don't match!

a + b   # ValueError: (3, 4) vs (1, 3) → axis 1: 4 ≠ 3, neither is 1

The fix: reshape b to a column vector so it broadcasts along rows:

a = np.ones((3, 4))
b = np.ones((3,))

# CORRECT — reshape to column vector (3, 1)
result = a + b[:, np.newaxis]   # (3, 4) + (3, 1) → (3, 4)
# Equivalent forms
result = a + b.reshape(3, 1)
result = a + b.reshape(-1, 1)   # -1 infers the size

Visual guide to common shape pairs:

import numpy as np

# These all work
np.ones((3, 4)) + np.ones((4,))      # (3,4) + (1,4) → (3,4)
np.ones((3, 4)) + np.ones((3, 1))    # (3,4) + (3,1) → (3,4)
np.ones((3, 4)) + np.ones((1, 4))    # (3,4) + (1,4) → (3,4)
np.ones((3, 4)) + np.ones((1, 1))    # (3,4) + (1,1) → (3,4)
np.ones((3, 4)) + 5                  # scalar always broadcasts

# These fail
np.ones((3, 4)) + np.ones((3,))      # (3,4) + (1,3) → axis 1: 4≠3 ✗
np.ones((3, 4)) + np.ones((2, 4))    # axis 0: 3≠2, neither is 1 ✗
np.ones((3, 4)) + np.ones((4, 3))    # axis 0: 3≠4, axis 1: 4≠3 ✗

Debugging unknown shape errors:

print(a.shape, b.shape)    # Always print shapes first
print(a.ndim, b.ndim)      # Number of dimensions

# Explicitly check before operating
assert a.shape[1] == b.shape[0], f"Shape mismatch: {a.shape} vs {b.shape}"

Fix 2: ValueError: setting an array element with a sequence

ValueError: setting an array element with a sequence. The requested array
has an inhomogeneous shape after 1 dimensions. The detected shape was (3,)
+ inhomogeneous part.

This error (introduced in NumPy 1.24) fires when you try to create an array from sequences of different lengths. NumPy can’t determine a valid shape:

import numpy as np

# WRONG — inner lists have different lengths
arr = np.array([[1, 2, 3], [4, 5]])   # ValueError in NumPy 1.24+

# CORRECT option 1 — make them the same length (pad if needed)
arr = np.array([[1, 2, 3], [4, 5, 0]])   # shape (2, 3)

# CORRECT option 2 — explicitly request object array (loses NumPy performance)
arr = np.array([[1, 2, 3], [4, 5]], dtype=object)
print(arr.shape)   # (2,) — an array of Python lists

This also fires when mixing scalars and arrays:

# WRONG — mixed scalar and list
arr = np.array([1, [2, 3]])   # ValueError

# CORRECT
arr = np.array([[1, 0], [2, 3]])   # Pad to same length

For ragged data in ML pipelines, use Python lists or Pandas object columns — not NumPy arrays. NumPy’s strength is uniform-shape numerical data.

Fix 3: dtype Errors — Integer Overflow and Type Surprises

NumPy’s integer types are fixed-width C integers. They silently overflow:

import numpy as np

# Silent integer overflow — no warning, no error
a = np.int32(2_147_483_647)    # max int32
print(a + 1)                    # -2147483648 (wrapped around!)

# Safe: use int64 for large numbers
a = np.int64(2_147_483_647)
print(a + 1)                    # 2147483648 ✓

# Or use Python int (unlimited precision) — slower but safe
a = int(2_147_483_647)
print(a + 1)                    # 2147483648 ✓

Default integer types differ by platform — in NumPy < 2.0, Windows defaults to int32 while Linux/macOS defaults to int64. Code that works on one platform silently produces different results on the other:

import numpy as np

arr = np.array([1, 2, 3])

# On Linux/macOS (NumPy < 2.0):
print(arr.dtype)   # int64

# On Windows (NumPy < 2.0):
print(arr.dtype)   # int32 — can overflow at 2 billion

# Explicit dtype to guarantee behavior everywhere
arr = np.array([1, 2, 3], dtype=np.int64)

np.bool, np.int, np.float, np.complex were removed in NumPy 1.24:

# WRONG — these aliases were removed in 1.24
arr = np.array([1, 0, 1], dtype=np.bool)     # AttributeError
arr = np.array([1, 2, 3], dtype=np.int)      # AttributeError
arr = np.array([1.0, 2.0], dtype=np.float)   # AttributeError

# CORRECT — use the underscore variants or Python built-ins
arr = np.array([1, 0, 1], dtype=np.bool_)    # NumPy bool
arr = np.array([1, 0, 1], dtype=bool)        # Python bool (same result)
arr = np.array([1, 2, 3], dtype=np.int64)    # Explicit integer width
arr = np.array([1.0, 2.0], dtype=np.float64) # Explicit float width
arr = np.array([1.0, 2.0], dtype=float)      # Python float (= float64)

Integer division produces floats in Python 3 but NumPy preserves dtype:

import numpy as np

a = np.array([7, 5, 3], dtype=np.int64)

print(a / 2)    # [3.5, 2.5, 1.5] — float64 result (true division)
print(a // 2)   # [3, 2, 1]       — int64 result (floor division)

# For ML: ensure float input to models
X = X.astype(np.float32)    # Convert before passing to PyTorch/TF

Type promotion in mixed operations:

import numpy as np

# int + float → float (upcasted)
print((np.int32(3) + np.float32(1.5)).dtype)   # float64

# float32 + float64 → float64 (upcasted)
a = np.ones(5, dtype=np.float32)
b = np.ones(5, dtype=np.float64)
print((a + b).dtype)   # float64

Pro Tip: PyTorch defaults to float32 and TensorFlow defaults to float32 for neural network weights. NumPy defaults to float64. Passing a NumPy float64 array to a PyTorch float32 model causes a dtype mismatch. Convert explicitly: arr.astype(np.float32) before creating tensors.

Fix 4: Axis Confusion — Wrong Dimension for sum, mean, max

ValueError: axis 2 is out of bounds for array of dimension 2

NumPy’s axis parameter specifies which dimension to collapse. Axis 0 is rows, axis 1 is columns — but the mental model trips up Pandas users because .sum(axis=1) in Pandas sums across columns (same result as NumPy), but the direction framing is easy to confuse.

import numpy as np

arr = np.array([
    [1, 2, 3],
    [4, 5, 6],
])
# shape: (2, 3) — 2 rows, 3 columns

print(arr.sum())          # 21 — all elements
print(arr.sum(axis=0))    # [5, 7, 9] — collapse rows, result has shape (3,)
print(arr.sum(axis=1))    # [6, 15]   — collapse columns, result has shape (2,)

# Mental model: axis=0 → "sum down the rows" (per-column result)
#               axis=1 → "sum across the columns" (per-row result)

keepdims=True preserves the reduced dimension as size 1, which is critical for broadcasting the result back:

import numpy as np

arr = np.random.rand(4, 3)   # (4, 3)

col_means = arr.mean(axis=0)             # shape (3,) — col-wise means
row_means = arr.mean(axis=1)             # shape (4,) — row-wise means

# Subtract column means from each row (normalize columns)
normalized = arr - col_means             # (4,3) - (3,) → broadcasts: ✓

# Subtract row means from each column (normalize rows)
# WRONG — (4,) pads to (1,4), can't broadcast with (4,3) axis 1
arr - row_means   # ValueError

# CORRECT — keepdims preserves shape (4,1), broadcasts to (4,3)
row_means = arr.mean(axis=1, keepdims=True)   # shape (4, 1)
normalized = arr - row_means                   # (4,3) - (4,1) → (4,3) ✓

argmax and argmin return the index of the max/min, not the value:

arr = np.array([[3, 1, 4], [1, 5, 9]])

print(arr.argmax())           # 5 — flat index of 9 (last element)
print(arr.argmax(axis=0))     # [0, 1, 1] — row index of max per column
print(arr.argmax(axis=1))     # [2, 2]   — col index of max per row
print(arr.max(axis=1))        # [4, 9]   — the actual max values

Fix 5: View vs Copy — Silent Modification Bugs

NumPy’s most subtle behavior: slices return views, not copies. Modifying a slice modifies the original array.

import numpy as np

original = np.array([1, 2, 3, 4, 5])

# SLICE — returns a view (shared memory)
view = original[1:4]
view[0] = 99

print(original)   # [1, 99, 3, 4, 5] — original was modified!
print(view)       # [99, 3, 4]

# FANCY INDEXING — returns a copy (no shared memory)
copy = original[[1, 2, 3]]
copy[0] = 0

print(original)   # [1, 99, 3, 4, 5] — original unchanged

Boolean indexing also returns a copy:

import numpy as np

arr = np.array([1, -2, 3, -4, 5])

# This does NOT modify arr — mask indexing returns a copy
arr[arr < 0] = 0     # WAIT — this one actually DOES work (in-place via __setitem__)
print(arr)           # [1, 0, 3, 0, 5] ✓

# But assigning to a variable from boolean indexing gets a copy
positives = arr[arr > 0]
positives[0] = 999
print(arr)           # [1, 0, 3, 0, 5] — unchanged; positives was a copy

Check whether two arrays share memory:

import numpy as np

a = np.array([1, 2, 3, 4])
b = a[1:3]       # view
c = a[[1, 2]]    # copy

print(np.shares_memory(a, b))   # True
print(np.shares_memory(a, c))   # False

# Force a copy when you need independence
b = a[1:3].copy()
print(np.shares_memory(a, b))   # False

Common Mistake: Functions like np.sort() return a new array but arr.sort() sorts in-place. This view/copy distinction is the same root cause as the pandas SettingWithCopyWarning — Pandas is built on NumPy and inherits the same memory model. Same for np.reshape() vs arr.reshape() — arr.reshape() returns a view when possible (same total elements) and a copy otherwise:

import numpy as np

arr = np.arange(12)

# reshape returns a view if possible
reshaped = arr.reshape(3, 4)
reshaped[0, 0] = 99
print(arr[0])   # 99 — arr was modified through the view

# Always copy if you need independence after reshape
reshaped = arr.reshape(3, 4).copy()

Fix 6: NaN and Inf — Propagation and Detection

import numpy as np

print(np.nan == np.nan)    # False — NaN is never equal to itself
print(np.nan != np.nan)    # True
print(np.nan + 5)          # nan — NaN propagates through all arithmetic

Detecting NaN and Inf:

import numpy as np

arr = np.array([1.0, np.nan, np.inf, -np.inf, 3.0])

print(np.isnan(arr))     # [False, True, False, False, False]
print(np.isinf(arr))     # [False, False, True, True, False]
print(np.isfinite(arr))  # [True, False, False, False, True]

# Count NaNs
print(np.isnan(arr).sum())   # 1

# Find positions
print(np.where(np.isnan(arr)))   # (array([1]),)

Replace NaN and Inf with usable values:

import numpy as np

arr = np.array([1.0, np.nan, np.inf, 3.0])

# nan_to_num: NaN → 0.0, +inf → large number, -inf → large negative number
clean = np.nan_to_num(arr)
print(clean)   # [1., 0., 1.7976931e+308, 3.]

# Control replacement values explicitly
clean = np.nan_to_num(arr, nan=0.0, posinf=999.0, neginf=-999.0)
print(clean)   # [1., 0., 999., 3.]

NaN-aware aggregations skip NaN values instead of propagating them:

import numpy as np

arr = np.array([1.0, np.nan, 3.0, np.nan, 5.0])

print(arr.sum())        # nan — NaN propagates
print(arr.mean())       # nan

print(np.nansum(arr))   # 9.0 — NaN skipped
print(np.nanmean(arr))  # 3.0
print(np.nanmax(arr))   # 5.0
print(np.nanmin(arr))   # 1.0
print(np.nanstd(arr))   # 1.632...

NaN in integer arrays requires a dtype that can represent NaN — integers can’t:

import numpy as np

# Integer arrays have no NaN — conversion needed
arr = np.array([1, 2, 3])
arr[1] = np.nan   # Silently converts to 0 (nan casts to int as 0)
print(arr)        # [1, 0, 3] — data silently lost!

# CORRECT — use float array for nullable integers
arr = np.array([1, 2, 3], dtype=np.float64)
arr[1] = np.nan
print(arr)   # [1., nan, 3.] ✓

Fix 7: Performance — Replace Python Loops with Vectorized Operations

NumPy operations run in compiled C code. Python loops over NumPy arrays throw away this advantage:

import numpy as np
import time

arr = np.random.rand(10_000_000)

# SLOW — Python loop: ~5 seconds
start = time.time()
result = np.zeros_like(arr)
for i in range(len(arr)):
    result[i] = arr[i] ** 2
print(f"Loop: {time.time() - start:.2f}s")

# FAST — NumPy vectorized: ~0.01 seconds (500x faster)
start = time.time()
result = arr ** 2
print(f"Vectorized: {time.time() - start:.4f}s")

Common vectorization patterns:

import numpy as np

arr = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
arr2d = np.random.rand(1000, 50)

# Element-wise operations — all vectorized
squared = arr ** 2
sqrt_arr = np.sqrt(arr)
clipped = np.clip(arr, 1.5, 3.5)          # Clamp to [1.5, 3.5]
normalized = (arr - arr.mean()) / arr.std() # Z-score normalization

# Replace if-else logic with np.where
positive_only = np.where(arr > 0, arr, 0.0)

# Replace loops over rows/columns with axis operations
row_norms = np.linalg.norm(arr2d, axis=1)   # L2 norm of each row
col_max = arr2d.max(axis=0)                  # Max per column

# Dot product and matrix multiplication
a = np.random.rand(100, 50)
b = np.random.rand(50, 30)
c = a @ b            # Matrix multiply, shape (100, 30)
c = np.dot(a, b)     # Same

np.vectorize() is still Python — it’s syntactic sugar over a loop, not a performance fix:

import numpy as np

# This is NOT faster than a loop
fast_fn = np.vectorize(lambda x: x ** 2)   # Still calls Python per element

# This IS fast
result = arr ** 2   # Vectorized C operation

Use np.vectorize() only for code clarity, never for performance.

Fix 8: Indexing Pitfalls — Advanced Indexing Edge Cases

Single-element indexing collapses a dimension:

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])   # shape (2, 3)

print(arr[0].shape)      # (3,) — dimension collapsed
print(arr[0:1].shape)    # (1, 3) — dimension preserved (slice)

# When passing to functions that expect 2D input
model.predict(arr[0])         # May fail — shape (3,) not (1, 3)
model.predict(arr[0:1])       # Works — shape (1, 3)
model.predict(arr[[0]])       # Works — fancy index preserves shape, (1, 3)
model.predict(arr[0][None])   # Works — np.newaxis adds dimension back

Negative indexing wraps around:

import numpy as np

arr = np.array([10, 20, 30, 40, 50])

print(arr[-1])     # 50 — last element
print(arr[-2])     # 40 — second to last
print(arr[-3:])    # [30, 40, 50]

Boolean indexing with mismatched mask:

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
mask = np.array([True, False, True])   # Wrong length

arr[mask]   # IndexError: boolean index did not match indexed array
            # along dimension 0; dimension is 5 but corresponding
            # boolean dimension is 3

# Fix: ensure mask length matches array
mask = arr > 2   # Shape matches arr automatically
print(arr[mask]) # [3, 4, 5]

np.where with two-argument form is different from one-argument form:

import numpy as np

arr = np.array([3, -1, 4, -1, 5])

# One argument — returns indices where condition is True (like np.nonzero)
indices = np.where(arr < 0)
print(indices)       # (array([1, 3]),)
print(arr[indices])  # [-1, -1]

# Three arguments — element-wise conditional (x where True, y where False)
result = np.where(arr < 0, 0, arr)   # Replace negatives with 0
print(result)   # [3, 0, 4, 0, 5]

Platform Differences: NumPy 2.0, ARM64 vs x86_64, BLAS Backends

NumPy is the foundation of the Python scientific stack, and the platform on which it runs determines its dtype defaults, performance, and which APIs work.

NumPy 2.0 (June 2024) was the first major release in 18 years and broke ABI compatibility. Code that imports np.float failed in 1.24 already; NumPy 2.0 went further and removed dozens of legacy aliases plus deprecated APIs. The most disruptive change for ML pipelines: the default integer dtype on Windows changed from int32 to int64, matching Linux and macOS. Code that silently overflowed on Windows now silently uses twice the memory. Some breaking changes to know:

# Removed in NumPy 2.0 — these all raise AttributeError now
np.in1d           # use np.isin
np.row_stack      # use np.vstack
np.cumproduct     # use np.cumprod
np.product        # use np.prod
np.alltrue        # use np.all
np.sometrue       # use np.any
np.NaN, np.Inf    # use np.nan, np.inf
np.PINF, np.NINF  # use np.inf, -np.inf

# Promotion rules changed
np.array([1], dtype=np.uint8) + 200   # 1.x: uint8 (overflow); 2.0: uint16

NumPy 2.0 also tightened type promotion — mixed-precision operations now follow NEP 50, which means scalars no longer upcast arrays to a wider dtype.

Use the migration script to find breaks before upgrading:

pip install numpy>=2.0.0
ruff check --select NPY201 .   # Ruff has NumPy 2.0 lint rules

ARM64 (Apple Silicon, Linux ARM) vs x86_64. Wheels exist for both on PyPI since NumPy 1.21, but the underlying BLAS library differs. On Apple Silicon, the default wheel links against Apple’s Accelerate framework — fast for everyday arrays but historically buggy for certain LAPACK routines (eigenvalue decomposition). NumPy 1.27+ fixed most Accelerate issues. On x86_64, pip-installed NumPy links against OpenBLAS.

MKL vs OpenBLAS. Intel MKL gives 2–10x speedup for large matrix multiplications on Intel and modern AMD CPUs. The catch: pip doesn’t ship MKL. To get it, install via Conda:

# Conda channel defaults — links against MKL on x86_64
conda install numpy

# Force MKL build
conda install numpy "blas=*=mkl"

# Or stick with OpenBLAS (smaller, no Intel runtime)
conda install numpy "blas=*=openblas"

Verify which BLAS is active:

import numpy as np
np.show_config()
# Look for "blas_info" or "openblas_info" — tells you the linked library

On Apple Silicon, MKL doesn’t exist. Use Accelerate (default with pip), OpenBLAS (via Conda), or build NumPy from source against libblas.

Free-threaded Python 3.13t removes the GIL. NumPy 2.1+ ships wheels for free-threaded Python (-cp313t- tag) — operations that previously required the GIL to release (large array math) can now run truly in parallel. Verify support:

python3.13t -c "import numpy; print(numpy.__version__, numpy._core._multiarray_umath.__file__)"
# Should not print warnings about GIL re-enable

If you hit “the GIL was re-enabled by importing a C extension”, a third-party package in your env isn’t free-threaded yet.

Windows-specific gotchas. Long paths in np.load() can fail with FileNotFoundError if the path exceeds 260 chars and Long Paths aren’t enabled. The tempfile directory NumPy uses for memory-mapped arrays inherits from TMP env var — set it to a drive with space if your default tempdir is small.

Memory-mapped arrays behave differently per OS. np.memmap on Linux uses real mmap(); on Windows it goes through CreateFileMapping. Closing the underlying file on Windows requires deleting the memmap object explicitly:

arr = np.memmap('big.dat', dtype='float32', mode='r+', shape=(10000, 10000))
arr.flush()
del arr   # Required on Windows before the file can be reopened or removed

Still Not Working?

NumPy 1.24 and 2.0 Removed APIs

The most common upgrade breakage:

Check your version: python -c "import numpy; print(numpy.__version__)".

np.matrix Is Deprecated — Use 2D Arrays

np.matrix has been deprecated for years. Its * operator means matrix multiply (not element-wise), which conflicts with regular arrays and causes confusing type errors when mixing them. Use 2D np.ndarray and the @ operator instead:

import numpy as np

a = np.random.rand(3, 4)
b = np.random.rand(4, 3)

# OLD — np.matrix with * for matmul
# m = np.matrix(a) * np.matrix(b)  # Deprecated

# CORRECT — 2D ndarray with @ operator
result = a @ b   # shape (3, 3)

Random Number Generation — Use the Generator API

np.random.seed() and np.random.rand() are the legacy interface. The modern API uses np.random.default_rng(), which is faster, more statistically sound, and supports parallel seeding:

import numpy as np

# LEGACY — module-level global state (avoid in new code)
np.random.seed(42)
arr = np.random.rand(100)

# MODERN — Generator with local state (preferred)
rng = np.random.default_rng(seed=42)
arr = rng.random(100)
integers = rng.integers(0, 10, size=50)
normal = rng.standard_normal(size=(100, 5))

# Independent generators for parallel jobs
rng1, rng2 = np.random.default_rng(0), np.random.default_rng(1)

Memory Layout — C vs Fortran Order

Some linear algebra operations and framework conversions depend on array memory layout:

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])

print(arr.flags['C_CONTIGUOUS'])   # True — rows stored contiguously (default)
print(arr.flags['F_CONTIGUOUS'])   # False — Fortran order (column-major)

# If a library requires Fortran-order (e.g., some BLAS routines)
arr_f = np.asfortranarray(arr)

# Force C-contiguous copy (useful before passing to C extensions)
arr_c = np.ascontiguousarray(arr)

Integrating NumPy with PyTorch and Polars

For PyTorch, NumPy arrays convert to tensors via torch.from_numpy() — but both share the same memory:

import numpy as np
import torch

arr = np.array([1.0, 2.0, 3.0])
tensor = torch.from_numpy(arr)

arr[0] = 99.0
print(tensor)   # tensor([99., 2., 3.]) — shared memory!

# To avoid shared memory, copy first
tensor = torch.tensor(arr)   # Always copies

For device and dtype issues when training PyTorch models on data prepared with NumPy, see PyTorch not working. For converting Polars DataFrames to NumPy with .to_numpy() and handling null values in that conversion, see Polars not working. For TensorFlow integration, see TensorFlow not working.

RuntimeError: module compiled against API version After Upgrade

This message means a C extension was built against a different NumPy ABI than the one currently installed. NumPy 2.0 broke ABI — packages built against 1.x crash at import until rebuilt. The fix: pip install --upgrade --force-reinstall <package> for any package shipping compiled extensions (pandas, scipy, scikit-learn, opencv-python). Pin all of them in a single requirements.txt to guarantee a coherent ABI.

np.save and Pickle Compatibility Across Versions

.npy files saved with NumPy 1.x load fine in 2.x, but pickled objects saved with np.save(..., allow_pickle=True) from 1.x containing object arrays may fail to load if the pickled class definitions changed. Prefer .npz archives with explicit dtypes over pickled object arrays for long-term storage.