Hướng dẫn is python jit compiled - python jit đã được biên dịch chưa

Tê liệt

Tài liệu lỗi thời

Bạn đang xem tài liệu lưu trữ từ trang web tài liệu Numba cũ. Tài liệu hiện tại được đặt tại https://numba.readthedocs.io.

Numba cung cấp một số tiện ích để tạo mã, nhưng tính năng trung tâm của nó là numba.jit() trang trí. Sử dụng bộ trang trí này, bạn có thể đánh dấu một chức năng để tối ưu hóa bằng trình biên dịch JIT Numba. Các chế độ gọi khác nhau kích hoạt các tùy chọn và hành vi biên dịch khác nhau.

Cách sử dụng cơ bản

Biên dịch lười biếng

Cách được đề xuất để sử dụng bộ trang trí

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
0 là để Numba quyết định khi nào và làm thế nào để tối ưu hóa:

from numba import jit

@jit
def f(x, y):
    # A somewhat trivial example
    return x + y

Trong chế độ này, biên dịch sẽ được hoãn lại cho đến khi thực thi hàm đầu tiên. Numba sẽ suy ra các loại đối số tại thời điểm gọi và tạo mã được tối ưu hóa dựa trên thông tin này. Numba cũng sẽ có thể biên dịch các chuyên ngành riêng biệt tùy thuộc vào các loại đầu vào. Ví dụ: gọi hàm

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
1 ở trên với số nguyên hoặc số phức sẽ tạo ra các đường dẫn mã khác nhau:

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)

Biên soạn háo hức

Bạn cũng có thể nói với Numba chữ ký chức năng mà bạn đang mong đợi. Hàm

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
1 bây giờ sẽ trông giống như:

from numba import jit, int32

@jit(int32(int32, int32))
def f(x, y):
    # A somewhat trivial example
    return x + y

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
3 là chữ ký của chức năng. Trong trường hợp này, chuyên ngành tương ứng sẽ được biên soạn bởi người trang trí
>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
0 và không có chuyên môn nào khác được cho phép. Điều này rất hữu ích nếu bạn muốn kiểm soát hạt mịn đối với các loại được chọn bởi trình biên dịch (ví dụ: để sử dụng phao chính xác đơn).

Nếu bạn bỏ qua loại trả về, ví dụ: Bằng cách viết

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
5 thay vì
>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
3, Numba sẽ cố gắng suy ra nó cho bạn. Chữ ký chức năng cũng có thể là chuỗi, và bạn có thể chuyển một số trong số chúng làm danh sách; Xem tài liệu numba.jit() để biết thêm chi tiết.

Tất nhiên, hàm được biên dịch cho kết quả dự kiến:

Và nếu chúng tôi chỉ định

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
8 là loại trả về, các bit bậc cao sẽ bị loại bỏ:

>>> f(2**31, 2**31 + 1)
1

Gọi và nội tuyến các chức năng khác

Các chức năng được biên dịch Numba có thể gọi các chức năng được biên dịch khác. Các cuộc gọi chức năng thậm chí có thể được in trong mã gốc, tùy thuộc vào heuristic của trình tối ưu hóa. Ví dụ:

@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))

Bộ trang trí

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
0 phải được thêm vào bất kỳ chức năng thư viện nào như vậy, nếu không Numba có thể tạo ra mã chậm hơn nhiều.

Thông số kỹ thuật chữ ký

Chữ ký

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
0 rõ ràng có thể sử dụng một số loại. Dưới đây là một số cái phổ biến:

  • from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    1 là loại chức năng trả về không trả lại gì (thực sự trả về
    from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    2 khi được gọi từ Python)

  • from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    3 và
    from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    4 là các số nguyên có kích thước con trỏ (được ký và không dấu, tương ứng)

  • from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    5 và
    from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    6 tương đương với C
    from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    7 và
    from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    8 Các loại số nguyên

  • from numba import jit, int32
    
    @jit(int32(int32, int32))
    def f(x, y):
        # A somewhat trivial example
        return x + y
    
    9,
    >>> f(2**31, 2**31 + 1)
    1
    
    0,
    >>> f(2**31, 2**31 + 1)
    1
    
    1,
    >>> f(2**31, 2**31 + 1)
    1
    
    2,
    >>> f(1, 2)
    3
    >>> f(1j, 2)
    (2+1j)
    
    8,
    >>> f(2**31, 2**31 + 1)
    1
    
    4,
    >>> f(2**31, 2**31 + 1)
    1
    
    5,
    >>> f(2**31, 2**31 + 1)
    1
    
    6 là số nguyên có chiều rộng cố định của chiều rộng bit tương ứng (đã ký và không dấu)

  • >>> f(2**31, 2**31 + 1)
    1
    
    7 và
    >>> f(2**31, 2**31 + 1)
    1
    
    8 là các số nổi chính xác đơn và kép, tương ứng

  • >>> f(2**31, 2**31 + 1)
    1
    
    9 và
    @jit
    def square(x):
        return x ** 2
    
    @jit
    def hypot(x, y):
        return math.sqrt(square(x) + square(y))
    
    0 lần lượt là các số phức đơn và kép, tương ứng

  • Các loại mảng có thể được chỉ định bằng cách lập chỉ mục bất kỳ loại số nào, ví dụ:

    @jit
    def square(x):
        return x ** 2
    
    @jit
    def hypot(x, y):
        return math.sqrt(square(x) + square(y))
    
    1 cho một mảng chính xác đơn một chiều hoặc
    @jit
    def square(x):
        return x ** 2
    
    @jit
    def hypot(x, y):
        return math.sqrt(square(x) + square(y))
    
    2 cho một mảng hai chiều của số nguyên 8 bit.

Tùy chọn biên dịch

Một số đối số chỉ có từ khóa có thể được chuyển cho trình trang trí

>>> f(1, 2)
3
>>> f(1j, 2)
(2+1j)
0.

________ 44¶

Numba có hai chế độ biên dịch: chế độ Nopython và chế độ đối tượng. Cái trước tạo ra mã nhanh hơn nhiều, nhưng có những hạn chế có thể buộc tê liệt trở lại sau này. Để ngăn chặn Numba rơi trở lại, và thay vào đó lại gây ra lỗi, hãy vượt qua

@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))
5.nopython mode and object mode. The former produces much faster code, but has limitations that can force Numba to fall back to the latter. To prevent Numba from falling back, and instead raise an error, pass
@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))
5.

@jit(nopython=True)
def f(x, y):
    return x + y

________ 46¶

Bất cứ khi nào Numba tối ưu hóa mã Python với mã gốc chỉ hoạt động trên các loại và biến gốc (thay vì các đối tượng Python), không cần phải giữ khóa phiên dịch toàn cầu Python (GiL). Numba sẽ phát hành GIL khi nhập chức năng được biên dịch như vậy nếu bạn vượt qua

@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))
7.global interpreter lock (GIL). Numba will release the GIL when entering such a compiled function if you passed
@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))
7.

@jit(nogil=True)
def f(x, y):
    return x + y

Mã chạy với GiL được phát hành đồng thời với các luồng khác thực thi mã Python hoặc Numba (cùng một hàm được biên dịch hoặc một chuỗi khác), cho phép bạn tận dụng các hệ thống đa lõi. Điều này sẽ không thể xảy ra nếu hàm được biên dịch ở chế độ đối tượng.object mode.

Khi sử dụng

@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))
7, bạn sẽ phải cảnh giác với những cạm bẫy thông thường của lập trình nhiều luồng (tính nhất quán, đồng bộ hóa, điều kiện chủng tộc, v.v.).

________ 49¶

Để tránh thời gian biên dịch mỗi lần bạn gọi chương trình Python, bạn có thể hướng dẫn Numba viết kết quả biên dịch chức năng vào bộ đệm dựa trên tệp. Điều này được thực hiện bằng cách vượt qua

@jit(nopython=True)
def f(x, y):
    return x + y
0:

@jit(cache=True)
def f(x, y):
    return x + y

________ 51¶

Cho phép tự động song song hóa (và tối ưu hóa liên quan) cho các hoạt động đó trong hàm được biết là có ngữ nghĩa song song. Để biết danh sách các hoạt động được hỗ trợ, hãy xem tự động song song với @JIT. Tính năng này được bật bằng cách vượt qua

@jit(nopython=True)
def f(x, y):
    return x + y
2 và phải được sử dụng cùng với
@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))
5:Automatic parallelization with @jit. This feature is enabled by passing
@jit(nopython=True)
def f(x, y):
    return x + y
2 and must be used in conjunction with
@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))
5:

@jit(nopython=True, parallel=True)
def f(x, y):
    return x + y