【性能优化秘籍】：深入理解NumPy数组的数据结构与性能提升


# 摘要
NumPy作为Python中科学计算的基础库，其数组对象提供了强大的数据结构支持和高效的性能。本文全面介绍了NumPy数组的基础知识、数据结构、性能优化方法以及在实际应用中的技术细节。首先概述了NumPy数组的基本概念和数据结构，然后深入探讨了如何通过避免Python循环、利用内置函数和优化内存使用来提升性能。进一步，文中阐述了内存对齐、高效数据输入输出和并行计算的高级性能技巧。此外，文章还提供了性能问题诊断的方法和案例分析，以及NumPy在大数据处理、机器学习和图像处理等实际项目中的应用。通过对NumPy的全面研究，本文旨在为开发者提供提升科学计算效率的实用指南。

# 关键字
NumPy数组；数据结构；性能优化；内存管理；并行计算；大数据处理

参考资源链接：[快速下载numpy 1.26.4轮子文件以支持Python 311](https://wenku.csdn.net/doc/5cs8537j7w?spm=1055.2635.3001.10343)
# 1. NumPy数组概述

NumPy是一个广泛应用于科学计算领域的Python库，其核心是提供一个多维数组对象（ndarray），这一特性为处理大数据集提供了便利。在本章节中，我们将简要介绍NumPy数组的基础知识，包括其定义、创建方法、基本属性和数据类型。

## 1.1 NumPy数组定义与创建

NumPy数组是同类型元素的多维集合，这些元素可能是数字、布尔值、字符串等。创建数组可以使用`numpy.array()`函数，它需要一个列表（list）作为输入参数。例如：

import numpy as np

# 一维数组
one_dimensional_array = np.array([1, 2, 3])

# 二维数组
two_dimensional_array = np.array([[1, 2, 3], [4, 5, 6]])

## 1.2 数组的属性

NumPy数组对象拥有一些属性，比如`ndim`代表数组的维度数，`shape`提供了维度的具体大小，`size`是数组中元素的总个数，而`dtype`指定了数组中元素的数据类型。例如：

print(one_dimensional_array.ndim)  # 输出维度数（1）
print(two_dimensional_array.shape) # 输出维度的具体大小 ((2, 3))
print(two_dimensional_array.size)  # 输出元素个数（6）
print(one_dimensional_array.dtype) # 输出数据类型（int32）

理解这些基础概念是利用NumPy进行高效数据操作的前提。后续章节我们将深入探讨NumPy数组的高级特性和性能优化技巧。

# 2. NumPy数组的数据结构剖析

### 2.1 NumPy数组基础

NumPy数组是构建任何科学计算项目的基石。理解这些基础对于掌握NumPy库乃至整个Python科学计算领域至关重要。

#### 2.1.1 数组的创建和维度理解

数组的创建是通过`numpy.array`函数进行的。该函数允许我们从列表、元组等Python序列对象创建数组。数组的维度理解，则涉及到了解数组的形状（shape）和秩（rank）。秩指的是数组的维数，而形状是每个维度上的元素数量。

import numpy as np

# 创建一维数组
one_d_array = np.array([1, 2, 3])
# 创建二维数组
two_d_array = np.array([[1, 2], [3, 4]])
# 创建三维数组
three_d_array = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

print("One-dimensional array:", one_d_array)
print("Two-dimensional array:\n", two_d_array)
print("Three-dimensional array:\n", three_d_array)

以上代码创建了不同维度的数组，并打印出来。其中，`one_d_array`是一个一维数组，`two_d_array`是一个二维数组，而`three_d_array`则是一个三维数组。

#### 2.1.2 数组类型与数组对象属性

数组类型是由数组中的数据类型决定的，例如整数、浮点数等。可以通过`dtype`属性查看。数组对象的其他属性还包括`ndim`（数组的维数）和`shape`（数组的维度大小）。

# 创建一个具有特定数据类型的数组
int_array = np.array([1, 2, 3], dtype=np.int64)
float_array = np.array([1.0, 2.0, 3.0], dtype=np.float32)

print("Data type of int_array:", int_array.dtype)
print("Number of dimensions of int_array:", int_array.ndim)
print("Shape of int_array:", int_array.shape)

print("Data type of float_array:", float_array.dtype)
print("Number of dimensions of float_array:", float_array.ndim)
print("Shape of float_array:", float_array.shape)

在上面的代码中，我们创建了两个不同数据类型的数组，并打印出了它们的数据类型、维数和形状属性。

### 2.2 数组数据类型详解

NumPy拥有丰富的数据类型支持，这使其在处理不同类型的数据时极为灵活。

#### 2.2.1 基本数据类型及其存储

NumPy支持多种基本数据类型，例如`int8`, `int16`, `int32`, `int64`, `float16`, `float32`, `float64`, `bool`, `complex64`, `complex128`等。每种数据类型都决定了存储数据的方式和大小。

# 创建不同数据类型的数组
int8_array = np.array([1, 2, 3], dtype=np.int8)
float32_array = np.array([1.0, 2.0, 3.0], dtype=np.float32)

print("8-bit integer array:", int8_array)
print("32-bit floating point array:", float32_array)

该代码块展示了如何创建不同数据类型的数组。`int8_array`以8位整数形式存储数据，而`float32_array`以32位浮点数形式存储数据。

#### 2.2.2 复杂数据类型与结构化数组

除了基本数据类型之外，NumPy还支持更复杂的结构化数据类型。这在处理结构化数据时特别有用，例如在处理记录形式的数据。

# 创建一个结构化数组
dt = np.dtype([('name', np.unicode_, 16), ('age', np.int8)])
data = [('Alice', 30), ('Bob', 25)]
structured_array = np.array(data, dtype=dt)

print("Structured array:", structured_array)

在这段代码中，我们定义了一个结构化数据类型`dt`，它包含字符串类型的名字和整数类型的年龄。然后我们创建了一个包含两个记录的结构化数组。

### 2.3 内存管理与视图机制

内存管理是任何编程语言中性能关键的一环，NumPy中的数组也不例外。

#### 2.3.1 数组的内存布局和连续性

NumPy数组中的数据是连续存储的。这种内存布局对于性能至关重要，尤其是在利用CPU缓存和进行向量化操作时。

# 创建一个数组
arr = np.array([1, 2, 3])

# 检查数组是否是连续的
print("Is the array contiguous in memory?:", arr.flags['C_CONTIGUOUS'])

在这段代码中，我们创建了一个一维数组，并使用`.flags`属性检查其内存布局。`C_CONTIGUOUS`标记表示数组是C风格连续的，即行主序（row-major order）。

#### 2.3.2 视图与副本的区别及其性能影响

在NumPy中，数组的视图和副本是两个不同的概念。理解它们之间的区别对于有效管理内存和优化性能至关重要。

# 创建一个数组
original_array = np.array([1, 2, 3])

# 创建一个视图
view_array = original_array

# 创建一个副本
copy_array = original_array.copy()

# 修改原始数组
original_array[0] = 10

print("Original array:", original_array)
print("View array:", view_array)
print("Copy array:", copy_array)

在这段代码中，我们创建了一个原始数组，并分别创建了一个视图和一个副本。修改原始数组后，视图中的数组也会发生变化，而副本中的数组则保持不变。

以上内容是对NumPy数组的数据结构剖析的第二章的部分内容，从基础、数据类型详解到内存管理与视图机制，循序渐进地帮助读者理解和掌握NumPy数组的核心概念。接下来的章节将深入探讨性能优化的策略和技巧，为进行高效数值计算打下坚实的基础。

# 3. NumPy性能优化基础

在处理大型数据集和需要高性能计算的场景时，性能优化是至关重要的。本章节将深入探讨如何通过NumPy提升计算性能，其中包括避免不必要的Python循环，充分利用NumPy的高效内置函数，以及如何优化内存使用。

## 3.1 避免Python循环

在使用NumPy处理数据时，循环是性能的常见瓶颈之一。NumPy的优势在于其数组操作的向量化，它将计算任务从Python层面下放到更底层的C语言实现，大幅提升了执行速度。

### 3.1.1 向量化操作的优势

向量化操作意味着在NumPy数组上应用函数时，不需要显式循环遍历数组的每一个元素。相反，操作会被自动应用到整个数组上。这种方法不仅代码更简洁，而且由于利用了底层优化，其执行速度也远远超过传统的循环。

举个例子，假设我们要对一个数组的每个元素加上一个常数，可以使用以下两种方法：

#### 传统Python循环方法

import numpy as np

# 创建一个数组
a = np.arange(1000000)

# 使用循环来增加每个元素
for i in range(len(a)):
    a[i] += 1

#### 向量化方法

import numpy as np

# 创建一个数组
a = np.arange(1000000)

# 使用向量化操作
a += 1

在向量化方法中，我们直接使用了`+=`操作符，这是NumPy对Python操作符的重载，内部实现了循环逻辑。对比两种方法的执行时间，向量化方法的性能提升是显而易见的。

### 3.1.2 利用广播机制简化代码

广播（Broadcasting）是NumPy中非常强大的一个特性，它允许不同形状的数组进行算术运算。这是通过自动扩展较小数组的形状来匹配较大数组的形状实现的。广播机制的使用不仅减少了代码量，同时也提高了计算效率。

例如，如果我们想对一个二维数组的每一行都加上一个一维数组，使用广播可以非常简单地做到这一点：

import numpy as np

# 创建一个二维数组和一个一维数组
A = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
b = np.array([1, 2, 3])

# 使用广播机制进行加法
C = A + b

在没有广播的情况下，我们可能需要显式地遍历每一行来完成加法，这会大大降低代码的执行效率。

## 3.2 利用NumPy的内置函数

NumPy库提供了大量高效的内置函数来处理数组，这些函数大多数都是用C语言实现的，因此执行速度远快于纯Python实现的函数。

### 3.2.1 常见的高效函数介绍

函数 | 描述
---|---
`np.add()` | 对数组元素进行加法运算
`np.subtract()` | 对数组元素进行减法运算
`np.multiply()` | 对数组元素进行乘法运算
`np.divide()` | 对数组元素进行除法运算
`np.sum()` | 计算数组元素的总和
`np.product()` | 计算数组元素的乘积

例如，我们想要计算一个数组中所有元素的平方和，可以使用`np.sum()`和`np.square()`函数：

import numpy as np

# 创建一个数组
a = np.array([1, 2, 3, 4, 5])

# 计算平方和
squared_sum = np.sum(np.square(a))

### 3.2.2 函数调用的性能分析

为了验证使用NumPy内置函数的性能优势，我们可以使用`%timeit`魔法命令在IPython中测试代码执行时间。通过这种方式，我们可以直观地看到向量化函数与传统Python循环在性能上的差异。

%timeit np.sum(np.square(a))

在大多数情况下，利用NumPy的内置函数可以显著提高计算速度。

## 3.3 优化内存使用

内存使用优化是性能提升的另一个关键方面。合理地使用内存，可以减少数据的读写次数，提高计算效率。

### 3.3.1 使用合适的数据类型

选择合适的数据类型对于减少内存消耗和提高性能至关重要。NumPy提供了多种数据类型，如`float64`、`float32`、`int32`等。使用较小的数据类型可以减少内存占用，同时也加快计算速度。

比如，如果数组中的数据是0到1之间的浮点数，我们可以使用`float32`而不是`float64`：

import numpy as np

# 创建一个float64类型的数组
a_float64 = np.random.rand(1000000)

# 创建一个float32类型的数组
a_float32 = np.random.rand(1000000).astype('float32')

# 比较两者的内存占用
print(a_float64.nbytes)  # float64类型数组的内存占用
print(a_float32.nbytes)  # float32类型数组的内存占用

### 3.3.2 增量式数组构建

在构建数组时，如果需要逐渐添加元素，应避免使用Python列表然后转换为NumPy数组的方式。更好的方法是使用`numpy.concatenate`或`numpy.vstack`等函数，这些函数可以在不创建新数组的情况下合并现有的数组片段。

import numpy as np

# 创建一个初始数组
a = np.empty(0)

# 使用append方式逐渐增加数组元素
for i in range(100000):
    a = np.append(a, i)

# 使用concatenate方式
b = np.empty((0,))  # 创建一个空的数组
for i in range(100000):
    b = np.concatenate((b, [i]))

通过这种方式构建数组，避免了频繁的内存重新分配，显著提高了效率。

以上是第三章的主要内容，展示了如何通过避免Python循环、利用NumPy的内置函数和优化内存使用来提升NumPy的性能。在后续的章节中，我们将深入探讨更多高级性能优化技巧以及如何诊断和解决性能问题。

# 4. NumPy高级性能技巧

在本章节中，我们将深入探讨一些NumPy的高级性能优化技巧，这些技巧在处理大规模数据集或对性能要求较高的场景中尤为重要。本章内容将帮助读者通过更高级的方法进一步提升代码效率，减少运行时间，优化内存使用，并探索并行计算的可能性。

## 4.1 内存对齐和预分配

### 4.1.1 理解内存对齐的概念

内存对齐指的是在内存中按照一定的规则将数据安排在特定边界上。这种做法可以提高数据读取的效率。大多数现代CPU在处理数据时，会对齐的数据访问更快。理解并正确应用内存对齐的概念，对于编写高效代码至关重要。

在NumPy中，可以通过`dtype`对象的`alignment`属性来查看不同数据类型的对齐方式。例如：

import numpy as np
print(np.dtype('int32').alignment)  # 输出 4
print(np.dtype('float64').alignment)  # 输出 8

通过这种方式，我们可以确保在创建数组时，元素的起始位置与CPU的偏好一致，从而提高访问速度。

### 4.1.2 使用空数组预分配内存

在处理循环创建数组的场景时，每次循环都创建一个新的数组会导致大量的内存分配和释放，这会消耗额外的时间。预分配内存是一种常见的优化手段，可以显著减少这种不必要的开销。

在NumPy中，可以使用`np.empty()`函数来创建一个未初始化的数组，然后再填充内容。例如：

import numpy as np
# 预分配一个大小为1000000的空数组
预先分配数组大小 = 1000000
a = np.empty(预先分配数组大小)
# 通过其他逻辑填充数组a

这种方法可以减少内存分配次数，从而提高性能。

## 4.2 高效的数据输入输出

### 4.2.1 使用内存映射文件

内存映射文件是一种允许程序使用文件的一部分作为数组进行读写的技术。它允许我们以一种非常高效的方式处理大文件，因为不需要将整个文件加载到内存中。

NumPy支持使用`np.memmap`来创建内存映射数组。例如：

# 创建一个内存映射的浮点型数组，大小为1000000个元素
a = np.memmap('filename.dat', dtype='float32', mode='w+', shape=(1000000,))

这种方式在处理大文件时尤其有用，因为它可以仅处理文件的一部分，同时避免不必要的内存占用。

### 4.2.2 利用数组的存储格式优化I/O

NumPy数组提供了多种存储格式，例如`.npy`和`.npz`，这些格式专门设计用来存储NumPy数组，可以有效地存储数据并快速读写。

使用NumPy的`save`和`load`函数可以将数组保存到磁盘，并重新加载它们：

# 将数组a保存到.npy文件
np.save('array.npy', a)

# 从.npy文件加载数组
b = np.load('array.npy')

通过这种方式，可以优化数组的输入输出过程，尤其是当需要频繁地读写大规模数据集时。

## 4.3 并行计算与多线程

### 4.3.1 NumPy中的并行策略

为了提升计算性能，NumPy利用了底层库（如BLAS和LAPACK）的多线程功能。用户可以通过设置环境变量来控制这些库使用的线程数，如`OPENBLAS_NUM_THREADS`或`MKL_NUM_THREADS`。

用户也可以选择使用支持并行计算的NumPy函数，例如`numpy.einsum`，它利用了现代CPU的SIMD（单指令多数据）扩展功能。

### 4.3.2 结合多线程提升计算性能

多线程可以显著提升计算密集型任务的性能。NumPy本身虽然没有直接的多线程支持，但是可以通过调用其他支持并行计算的库来实现。

例如，使用Python的`concurrent.futures`模块来并行化NumPy操作：

from concurrent.futures import ThreadPoolExecutor
import numpy as np

def compute_chunk(chunk):
    # 对数组的一部分执行计算
    return np.square(chunk)

# 假设有一个大数组a需要被计算
chunks = np.array_split(a, 4)
with ThreadPoolExecutor() as executor:
    results = executor.map(compute_chunk, chunks)
    a = np.concatenate(list(results))

通过上述代码，我们可以将数组分成多个部分，并利用多线程同时对各个部分进行计算，从而提高整体性能。

在本章中，我们了解了内存对齐和预分配、高效的数据输入输出以及并行计算与多线程等高级技巧。这些技术可以帮助开发者在实际项目中显著提升NumPy代码的性能。接下来的章节将介绍性能问题诊断的相关内容。

# 5. NumPy性能问题诊断

在进行大规模数据处理和机器学习模型训练时，性能问题常常是项目开发和维护过程中的重大障碍。NumPy作为一个广泛使用的数值计算库，对性能的要求尤其重要。性能问题可能源自代码效率、数据结构设计、内存使用不当等多个方面。在本章节中，我们将深入探讨如何诊断和解决这些性能问题。

## 5.1 性能瓶颈定位

### 5.1.1 使用性能分析工具

在性能优化的过程中，首先需要确定瓶颈所在。这可以通过性能分析工具来实现。Python有多种性能分析工具，如`cProfile`和`line_profiler`，它们可以提供函数调用的执行时间信息，帮助开发者识别出程序中最耗时的部分。

**代码示例：使用`cProfile`进行性能分析**

import cProfile

def compute(array):
    # 这里是一些复杂的计算
    pass

def main():
    large_array = np.random.rand(10000, 10000)
    compute(large_array)

if __name__ == "__main__":
    profiler = cProfile.Profile()
    profiler.enable()
    main()
    profiler.disable()
    profiler.print_stats()

该代码段演示了使用`cProfile`模块来分析名为`main`的函数的性能。分析结果将显示每个函数调用的累计时间和调用次数，这是寻找性能瓶颈的一个很好的起点。

### 5.1.2 识别低效代码段

一旦有了性能分析数据，下一步就是分析这些数据并找出低效代码。一种常见的做法是查看耗时最长的几个函数，并对它们进行优化。例如，使用NumPy的内置函数通常比纯Python代码执行得更快，因为它们是用C语言编写的，并针对性能进行了优化。

## 5.2 常见性能陷阱及解决方案

### 5.2.1 对象数组的性能影响

NumPy数组可以包含对象，而这些对象数组的性能可能会比原生类型数组差很多。这是因为Python的对象模型要求更多的内存分配和间接引用，从而降低了性能。

**避免对象数组的性能影响**

- 尽可能使用原生类型数组，如`int`, `float`, `complex`, 等等。
- 如果需要使用对象数组，请尽量使用统一的对象类型，并考虑使用结构化数组来限制类型转换。

### 5.2.2 避免不必要的数据复制

在处理NumPy数组时，经常会出现无意中复制数组数据的情况。例如，使用数组的切片操作时，如果没有特别的说明，NumPy默认会复制数据而不是创建视图。

**代码示例：避免不必要的数据复制**

import numpy as np

a = np.arange(1000000)
b = a[::2]  # 默认创建一个视图，而非复制
b[0] = 0     # 修改b的第一个元素，a也会相应改变

在上面的代码中，`b`是`a`的视图而非复制。如果确实需要复制，可以使用`copy()`方法显式地指示：

c = a[::2].copy()  # 现在c是a的一个副本，两者是独立的

## 5.3 实际案例分析

### 5.3.1 从常见问题中学习

一个典型的性能问题案例是处理大规模图像数据。例如，在使用NumPy进行图像处理时，开发者可能会在无意中对整个图像数据进行不必要的复制。

**案例分析：图像处理中的性能问题**

from PIL import Image
import numpy as np

# 加载一张高分辨率的图像
image = Image.open("highres_image.jpg")
# 将图像转换为NumPy数组
array_image = np.array(image)

# 做一些处理
# ... 这里可能出现性能问题 ...

在上面的代码中，将图像文件转换为NumPy数组可能会创建一个巨大的数组。如果在进一步的操作中没有注意视图与副本的区别，就可能无意中进行大量的数据复制，从而影响性能。

### 5.3.2 案例优化过程演示

优化的起点是分析性能瓶颈。使用性能分析工具后，我们可能发现以下步骤中存在性能问题：

1. **图像转换**：将图像转换为NumPy数组。
2. **数据处理**：进行图像处理操作，如滤波、边缘检测等。

针对这些步骤，我们可以采取以下优化措施：

1. **批量化处理**：将图像分成多个小块进行处理，以减少内存占用。
2. **使用视图而非副本**：在可能的情况下，使用NumPy数组的视图而非副本。
3. **利用NumPy内置函数**：在图像处理中尽可能使用NumPy提供的内置函数，它们通常都经过优化，比自定义的Python代码更快。

通过这些方法，我们可以显著提高大规模数据处理的性能。

# 6. NumPy在实际项目中的应用

## 6.1 大数据处理

在处理大量数据时，NumPy数组由于其高效的内存布局和快速的算术运算能力，成为了处理大数据集的首选工具。我们可以利用NumPy进行数据的快速读取、处理和分析。

### 6.1.1 利用NumPy处理海量数据

使用NumPy处理大数据的一个关键策略是减少数据的内存占用。通过选择合适的数据类型和使用视图而非副本，我们可以在保证数据处理速度的同时，尽可能减少内存的使用。

import numpy as np

# 生成一个大的随机整数数组
large_array = np.random.randint(0, 1000, size=(10000000, 3))

# 使用更紧凑的数据类型以节省内存
large_array = large_array.astype(np.uint8)

在上例中，我们创建了一个包含1000万行3列的随机整数数组，并将数据类型从默认的64位整数压缩到了8位无符号整数，从而大幅减少了内存的占用。

### 6.1.2 内存效率与数据清洗技巧

在数据清洗过程中，使用NumPy可以极大地提高效率，特别是当涉及到数组操作时。例如，我们可以快速移除或替换不符合条件的数据。

# 创建一个随机浮点数数组
data = np.random.randn(100000)

# 使用条件索引过滤掉大于3的数据
filtered_data = data[data < 3]

在这个例子中，我们用条件索引的方式移除了数组中所有大于3的值，这是一种非常高效的数据清洗手段。

## 6.2 机器学习中的性能优化

机器学习任务往往涉及大量的矩阵运算和数据处理，使用NumPy可以显著提升这些任务的处理速度。

### 6.2.1 NumPy在数据预处理中的应用

在数据预处理阶段，我们可以利用NumPy进行特征缩放、归一化以及生成验证集等操作。

# 假设有一组特征数据
features = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 特征缩放，将特征缩放到0到1之间
features_normalized = (features - features.min(axis=0)) / (features.max(axis=0) - features.min(axis=0))

这里我们使用了简单的特征缩放公式，将特征值缩放到了0到1的范围内，这样有助于某些机器学习模型更快地收敛。

### 6.2.2 加速机器学习模型的训练和预测

在模型的训练和预测阶段，NumPy数组通常被转换为更高级的数据结构，比如Pandas的DataFrame或者直接输入到机器学习框架中。但即便是这样，原始的NumPy数组仍然是不可或缺的，特别是在需要进行大规模矩阵运算时。

# 创建一个样本矩阵和目标向量
X = np.random.rand(100, 10)  # 100个样本，每个样本10个特征
y = np.random.randint(0, 2, size=(100,))  # 二分类问题的目标向量

# 使用逻辑回归模型进行预测
# 注意：这只是一个示例，实际模型训练需要使用机器学习库如scikit-learn
prediction = X @ some_weight_vector > 0.5

在这个例子中，我们通过一个简单的逻辑回归预测展示了NumPy在模型预测阶段的快速矩阵运算能力。

## 6.3 图形与图像处理

NumPy由于其高效的数组操作能力，也被广泛应用于图形与图像处理领域。

### 6.3.1 利用NumPy进行图像数组操作

在图像处理中，图像可以被看作是一个多维数组，其中的每个元素代表图像的一个像素。使用NumPy，我们可以轻松执行各种像素级别的操作。

# 读取一张图像并将其转换为NumPy数组
from PIL import Image
import numpy as np

img = Image.open('example.jpg')
img_array = np.array(img)

# 将图像转换为灰度
gray_img = img_array.dot([0.299, 0.587, 0.114])

# 显示图像
Image.fromarray(gray_img.astype('uint8'))

在这个例子中，我们读取了一张图像，并将其转换为灰度图像，这在图像处理中是一个常见的操作。

### 6.3.2 图像处理中的性能优化技巧

图像处理操作往往对性能要求很高，NumPy通过优化过的数组操作来满足这一需求。

# 对图像数组进行滤波处理
def apply_filter(image_array):
    kernel = np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]])  # 一个简单的滤波核
    filtered = np.zeros_like(image_array)
    for i in range(1, image_array.shape[0] - 1):
        for j in range(1, image_array.shape[1] - 1):
            filtered[i, j] = np.sum(image_array[i-1:i+2, j-1:j+2] * kernel)
    return filtered

# 测试滤波函数性能
# 注意：为了得到性能指标，实际测试时应使用性能分析工具
filtered_image = apply_filter(gray_img)

这个简单的滤波函数演示了如何使用NumPy对图像进行处理。在实际应用中，可以使用更高级的函数如`scipy.signal.convolve2d`来进行二维卷积，这通常会更高效。

NumPy在处理大数据集、机器学习任务和图像处理中的应用展示了其在实际项目中的重要性。熟练地使用NumPy能够显著提升代码的执行效率，简化数据处理流程。