Cython與Numba：Python效能最佳化實戰

– 12 分鐘閱讀

Cython和Numba是兩種廣泛使用的Python效能最佳化工具。Cython允許將Python程式碼編譯成C程式碼，而Numba則利用JIT編譯技術將Python程式碼編譯成機器碼。本文將探討如何使用這兩種工具來最佳化Python程式碼，並結合NumPy進行效能提升。首先，我們會介紹Cython的基本用法，包括安裝、編譯和使用ctypes載入共用函式庫。接著，我們將深入探討Cython的效能最佳化技巧，例如停用邊界檢查、除零檢查和使用型別宣告。然後，我們會介紹Numba的JIT編譯器，並示範如何使用它來最佳化Python函式。最後，我們將比較Cython和Numba的效能，並討論它們各自的優缺點。

安裝Cython

首先，您需要安裝Cython。您可以使用pip安裝Cython：

pip install cython

建立Cython檔案

接下來，建立一個新的檔案，例如my_cython.pyx，並在其中新增您的Python程式碼。例如：

# my_cython.pyx
def my_function(x):
    return x * 2

編譯Cython檔案

然後，編譯Cython檔案為C程式碼：

cython my_cython.pyx

這將生成一個my_cython.c檔案。

編譯C程式碼

接下來，編譯C程式碼為共用函式庫：

gcc -shared -o my_cython.so my_cython.c -fPIC

這將生成一個my_cython.so檔案。

載入共用函式庫

最後，載入共用函式庫並使用您的Cython函式：

import ctypes
my_cython = ctypes.CDLL('./my_cython.so')
my_cython.my_function.argtypes = [ctypes.c_int]
my_cython.my_function.restype = ctypes.c_int

result = my_cython.my_function(5)
print(result)  # 輸出：10

效能最佳化

Cython提供了多種方法來最佳化效能，包括：

  • 停用邊界檢查：您可以使用@cython.boundscheck(False)裝飾器或with cython.boundscheck(False):陳述式停用邊界檢查。
  • 停用除零檢查：您可以使用@cython.cdivision(True)裝飾器或with cython.cdivision(True):陳述式停用除零檢查。
  • 使用型別宣告：您可以使用型別宣告來指定變數的型別，例如cdef int x。

示例

以下是使用Cython最佳化Python程式碼的示例：

# my_cython.pyx
cimport cython

@cython.boundscheck(False)
@cython.cdivision(True)
def my_function(double[:] x):
    cdef int i
    cdef double result = 0
    for i in range(len(x)):
        result += x[i]
    return result

benchmarking

您可以使用timeit模組來測試Cython程式碼的效能：

import timeit

def benchmark():
    import numpy as np
    x = np.random.rand(1000)
    return my_function(x)

print(timeit.timeit(benchmark, number=100))

這將輸出執行benchmark函式100次的平均時間。

最佳化Chebyshev距離計算的效能

Chebyshev距離是一種度量兩個點之間的距離的方法，尤其是在多維空間中。然而，當我們需要計算大量點之間的距離時，效能就變得非常重要。在這個例子中，我們將探討如何使用Cython來最佳化Chebyshev距離的計算。

使用Cython最佳化Chebyshev距離計算

Cython是一種可以將Python程式碼編譯成C程式碼的工具，從而可以提高Python程式碼的執行速度。要使用Cython最佳化Chebyshev距離計算，我們需要將計算Chebyshev距離的程式碼寫成Cython程式碼。

# cython: profile=True
cdef int max(int a, int b):
    if a > b:
        return a
    else:
        return b

cdef int min(int a, int b):
    if a < b:
        return a
    else:
        return b

cdef int chebyshev(int x1, int x2, int y1, int y2):
    cdef int dx = max(x1, x2) - min(x1, x2)
    cdef int dy = max(y1, y2) - min(y1, y2)
    return max(dx, dy)

使用Python進行效能測試

要測試Cython最佳化後的Chebyshev距離計算的效能，我們可以使用Python的timeit模組。

import timeit
import numpy as np

# 生成隨機資料
a = np.random.rand(100, 2)
b = np.random.rand(100, 2)

# 定義Chebyshev距離計算函式
def chebyshev_distance(x1, x2, y1, y2):
    return max(abs(x1 - x2), abs(y1 - y2))

# 測試效能
def benchmark():
    for x1, y1 in a:
        for x2, y2 in b:
            chebyshev_distance(x1, x2, y1, y2)

print(timeit.timeit(benchmark, number=10))

效能比較

透過Cython最佳化Chebyshev距離計算後，效能有了明顯的提高。以下是效能比較的結果：

方法執行時間
原始Python程式碼2.066秒
Cython最佳化後0.351秒

可以看到，Cython最佳化後的Chebyshev距離計算的執行時間大大減少，從2.066秒減少到0.351秒，效能提高了約5倍。

圖表翻譯：

  flowchart TD
    A[原始Python程式碼] --> B[Cython最佳化]
    B --> C[效能比較]
    C --> D[結果]
    D --> E[效能提高]

圖表翻譯：此圖表展示了從原始Python程式碼到Cython最佳化的過程，最後得到效能提高的結果。

最佳化Python程式碼的效能

在最佳化Python程式碼的效能時，瞭解程式碼的瓶頸是非常重要的。透過使用像是cProfile這樣的工具，可以找出哪些部分的程式碼消耗了最多的時間。

分析效能瓶頸

從輸出的結果可以看出，max函式並不是瓶頸所在。最花時間的部分似乎是在benchmark函式內，這意味著純Python的for loop可能是導致效能低下的原因。為了改善這個問題，將for loop重寫成使用NumPy或是將程式碼移植到Cython可能是最佳的策略。

使用Cython加速Python程式碼

Cython是一個允許你將Python程式碼編譯成C程式碼的工具，從而能夠大幅度提高Python程式碼的執行速度。尤其是對於那些計算密集的程式碼，使用Cython可以帶來顯著的效能提升。

在Jupyter Notebook中使用Cython

幸運的是，Cython可以很方便地與Jupyter Notebook整合在一起。這意味著你可以在Jupyter Notebook中直接編譯和執行Cython程式碼，而不需要離開Notebook環境。

載入Cython魔術

要在Jupyter Notebook中使用Cython，你需要先載入Cython魔術。這可以透過在Notebook的一個儲存格中輸入 %load_ext cython 來完成。

編譯和執行Cython程式碼

一旦Cython魔術被載入，你就可以使用 %%cython 魔術來編譯和執行Cython程式碼。例如，你可以將以下程式碼複製到Notebook的一個儲存格中：

%%cython

import numpy as np

cdef int max(int a, int b):
    return a if a > b else b

cdef int chebyshev(int x1, int y1, int x2, int y2):
    return max(abs(x1 - x2), abs(y1 - y2))

def c_benchmark():
    a = np.random.rand(1000, 2)
    # ... 其他程式碼 ...

這樣，你就可以在Jupyter Notebook中直接編譯和執行Cython程式碼，從而享受Cython帶來的效能提升。

最佳化Python效能：Cython和NumPy

在處理大規模資料時，Python的效能可能會成為瓶頸。為了解決這個問題，我們可以使用Cython和NumPy來最佳化我們的程式碼。

Cython簡介

Cython是一種程式語言，它允許我們將Python程式碼編譯成C程式碼，從而提高效能。Cython的語法與Python非常相似，但它提供了更多的控制和最佳化選項。

使用Cython最佳化程式碼

要使用Cython最佳化程式碼，我們需要將Python程式碼轉換成Cython程式碼。下面是一個例子：

# cython: linetrace=True
# cython: binding=True

import numpy as np

cdef int max(int a, int b):
    return a if a > b else b

def chebyshev(int x1, int y1, int x2, int y2):
    return max(abs(x1 - x2), abs(y1 - y2))

def c_benchmark():
    a = np.random.rand(1000, 2)
    b = np.random.rand(1000, 2)
    for x1, y1 in a:
        for x2, y2 in b:
            chebyshev(x1, y1, x2, y2)

在這個例子中，我們使用Cython的cdef關鍵字來定義一個C函式max。我們還使用cython: linetrace=True和cython: binding=True來啟用行追蹤和繫結。

使用NumPy最佳化程式碼

NumPy是一種用於高效能計算的Python函式庫。它提供了一個多維陣列物件，並支援各種數學運算。下面是一個例子：

import numpy as np

def numpy_benchmark():
    a = np.random.rand(1000, 2)
    b = np.random.rand(1000, 2)
    for x1, y1 in a:
        for x2, y2 in b:
            np.maximum(np.abs(x1 - x2), np.abs(y1 - y2))

在這個例子中，我們使用NumPy的np.random.rand函式來生成兩個隨機陣列。我們還使用NumPy的np.maximum函式來計算兩個陣列的最大值。

效能比較

我們可以使用timeit模組來比較Cython和NumPy的效能。下面是一個例子：

import timeit

def cython_benchmark():
    # Cython程式碼

def numpy_benchmark():
    # NumPy程式碼

cython_time = timeit.timeit(cython_benchmark, number=100)
numpy_time = timeit.timeit(numpy_benchmark, number=100)

print(f"Cython時間：{cython_time:.2f}秒")
print(f"NumPy時間：{numpy_time:.2f}秒")

在這個例子中，我們使用timeit.timeit函式來測量Cython和NumPy程式碼的執行時間。我們可以看到Cython程式碼的執行時間明顯短於NumPy程式碼。

圖表翻譯：

  flowchart TD
    A[開始] --> B[生成隨機資料]
    B --> C[計算Chebyshev距離]
    C --> D[比較Cython和NumPy的效能]
    D --> E[輸出結果]

在這個圖表中，我們可以看到Cython和NumPy程式碼的執行流程。我們首先生成隨機資料，然後計算Chebyshev距離，最後比較Cython和NumPy的效能並輸出結果。

最佳化Python程式的效能

在進行大規模的資料處理和科學計算時，Python的效能可能會成為一個瓶頸。為了改善這種情況，我們可以使用各種工具和技術來最佳化Python程式的效能。

使用NumPy進行資料處理

NumPy是Python中的一個函式庫，提供了高效的資料處理功能。它可以讓我們使用向量化操作來處理大規模的資料，從而大大提高效能。

import numpy as np

# 生成兩個隨機陣列
a = np.random.rand(1000, 2)
b = np.random.rand(1000, 2)

# 定義一個距離計算函式
def chebyshev(x1, x2, y1, y2):
    return max(abs(x1 - x2), abs(y1 - y2))

# 使用NumPy進行距離計算
distances = np.zeros((len(a), len(b)))
for i, (x1, y1) in enumerate(a):
    for j, (x2, y2) in enumerate(b):
        distances[i, j] = chebyshev(x1, x2, y1, y2)

使用Cython進行最佳化

Cython是一個可以將Python程式編譯成C程式的工具。它可以讓我們使用C的效能來最佳化Python程式。

# cython: language_level=3

import numpy as np

cdef double chebyshev(double x1, double x2, double y1, double y2):
    return max(abs(x1 - x2), abs(y1 - y2))

def c_benchmark():
    cdef int i, j
    cdef double x1, x2, y1, y2
    cdef np.ndarray[double, ndim=2] a = np.random.rand(1000, 2)
    cdef np.ndarray[double, ndim=2] b = np.random.rand(1000, 2)
    cdef np.ndarray[double, ndim=2] distances = np.zeros((len(a), len(b)))

    for i in range(len(a)):
        x1, y1 = a[i, 0], a[i, 1]
        for j in range(len(b)):
            x2, y2 = b[j, 0], b[j, 1]
            distances[i, j] = chebyshev(x1, x2, y1, y2)
    return distances

使用line_profiler進行效能分析

line_profiler是一個可以用來分析Python程式效能的工具。它可以讓我們知道哪些部分的程式碼消耗了最多的時間。

%load_ext line_profiler
%lprun -f c_benchmark c_benchmark()

結果分析

使用line_profiler進行效能分析後，我們可以看到哪些部分的程式碼消耗了最多的時間。這可以幫助我們針對性地最佳化程式碼。

Timer unit: 1e-06 s
Total time: 2.322 s
File: /home/gabriele/.cache/ipython/cython/_cython_magic_18ad8204e9d29650f3b09feb48ab0f44.pyx

Function: c_benchmark at line 11

Line # Hits Time Per Hit % Time Line Contents

==============================================================

11 def c_benchmark():

12 1 226 226.0 0.0 a = np.random.rand...

13 1 67 67.0 0.0 b = np.random.rand...

14

15 1001 1715 1.7 0.1 for x1, y1 in a:

什麼是Numba？

Numba是一個Python函式庫，設計用於編譯小型函式以提高程式的執行效率。它使用Low-Level Virtual Machine（LLVM）工具鏈，在執行時編譯Python函式為機器碼。

Numba的工作原理

Numba透過使用LLVM將Python函式編譯為中間表示（IR），然後將IR編譯為特定平臺的機器碼。Numba實作了型別推斷演算法，以猜測變數和函式的型別，然後編譯出型別感知版本的函式以進行快速執行。

Numba的優點

Numba的優點包括：

  • 能夠編譯Python函式為機器碼，以提高執行效率
  • 支援型別推斷，能夠自動猜測變數和函式的型別
  • 能夠與NumPy陣列進行最佳化

Numba的限制

Numba的限制包括：

  • 只能編譯小型函式
  • 需要使用LLVM工具鏈
  • 並非所有Python函式都能夠被編譯

如何使用Numba

Numba可以透過裝飾器的方式將其整合到Python程式中。以下是使用Numba裝飾器的步驟：

  1. 定義一個Python函式
  2. 使用Numba裝飾器標記函式，例如@numba.jit
  3. 執行函式，Numba將在執行時編譯函式為機器碼

Numba的範例

以下是使用Numba編譯一個計算陣列平方和的函式的範例：

import numba

@numba.jit
def sum_of_squares(arr):
    sum = 0
    for i in range(len(arr)):
        sum += arr[i] ** 2
    return sum

arr = [1, 2, 3, 4, 5]
result = sum_of_squares(arr)
print(result)

在這個範例中，sum_of_squares函式被標記為@numba.jit，Numba將在執行時編譯此函式為機器碼。

最佳化函式效能：Numba JIT 編譯器

介紹

在最佳化函式效能方面，Numba 的 JIT 編譯器是一個非常有用的工具。透過應用 @nb.jit 裝飾器，我們可以將 Python 函式編譯為機器碼，從而獲得顯著的效能提升。

示例：最佳化求和函式

讓我們考慮一個簡單的函式，計算一個陣列的元素之和：

def sum_sq(a):
    result = 0
    N = len(a)
    for i in range(N):
        result += a[i]
    return result

要使用 Numba 最佳化這個函式，我們只需在函式定義前新增 @nb.jit 裝飾器：

from numba import nb
@nb.jit
def sum_sq(a):
    result = 0
    N = len(a)
    for i in range(N):
        result += a[i]
    return result

效能比較

為了評估 Numba 最佳化的效果，我們可以比較原始函式和最佳化函式的執行時間。我們可以使用 timeit 模組來測量函式的執行時間：

import numpy as np
x = np.random.rand(10000)

# 原始函式
%timeit sum_sq.py_func(x)

# 最佳化函式
%timeit sum_sq(x)

透過比較兩個函式的執行時間，我們可以看到 Numba 最佳化函式的效能提升。

總結

在本例中，我們展示瞭如何使用 Numba 的 JIT 編譯器最佳化一個簡單的函式。透過應用 @nb.jit 裝飾器，我們可以獲得顯著的效能提升。這種最佳化技術可以應用於更復雜的函式和演算法，從而提高整個應用程式的效能。

內容解密：

在上述示例中，我們使用 @nb.jit 裝飾器最佳化了 sum_sq 函式。這個裝飾器告訴 Numba 編譯器在函式第一次被呼叫時編譯函式。這樣，Numba 可以檢測輸入引數的型別並生成一個特化的、效能最佳化的函式版本。

圖表翻譯：

  flowchart TD
    A[原始函式] --> B[應用 @nb.jit 裝飾器]
    B --> C[編譯函式]
    C --> D[最佳化函式]
    D --> E[執行函式]
    E --> F[比較執行時間]

在這個圖表中，我們展示了從原始函式到最佳化函式的整個過程。首先，我們應用 @nb.jit 裝飾器，然後 Numba 編譯器編譯函式。最後，我們執行最佳化函式並比較其執行時間與原始函式的執行時間。

Numba 的魔力：提升 Python 程式碼的執行效率

在上一節中，我們看到 Numba 如何透過簡單的裝飾器大幅提升 Python 程式碼的執行效率。讓我們更深入地探討 Numba 的工作原理和其優缺點。

從技術效能最佳化視角來看，Cython和Numba為Python效能提升提供了強大的解決方案。透過將Python程式碼編譯成C或機器碼，它們繞過了Python直譯器的效能瓶頸，尤其在處理密集數值計算時效果顯著。分析顯示，Cython在處理迴圈和陣列操作時表現出色，而Numba則更擅長處理小型函式和數學運算。然而，兩者並非完美無缺。Cython需要額外的編譯步驟，增加了開發流程的複雜度，而Numba的型別推斷機制並非適用於所有Python程式碼，某些情況下需要手動指定型別。對於追求極致效能的開發者，建議深入理解兩者的底層機制和適用場景，並結合實際案例進行效能測試和比較，選擇最適合的最佳化方案。展望未來，隨著這兩個工具的持續發展和社群的積極貢獻，它們將在Python高效能運算領域扮演越來越重要的角色，並進一步降低Python程式碼最佳化的門檻。玄貓認為，在特定效能瓶頸明顯的場景下，Cython和Numba值得優先考慮，但需謹慎評估其引入的額外開發成本。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。