0
雷鋒網(wǎng) AI 研習社按：本文的作者是來自 Hugging face 的科學家 Thomas Wolf，他的研究方向包括機器學習、自然語言處理和深度學習。在這篇博客中，他介紹了如何利用 Cython 和 spaCy 讓 Python 在自然語言處理任務中獲得百倍加速。雷鋒網(wǎng) AI 研習社根據(jù)原文進行了編譯。
SpaceX 獵鷹重型發(fā)射器，版權歸 SpaceX 所有
提示：本文中涉及的所有例子都可以在這個 Jupyter notebook 中獲得源碼。
在去年我們發(fā)布了用 Python 實現(xiàn)的基于神經(jīng)網(wǎng)絡的相互引用解析包（Neural coreference resolution package）之后，在社區(qū)中獲得了驚人數(shù)量的反饋，許多人開始將該解析包用到各種各樣的應用中，有一些應用場景甚至已經(jīng)超出了我們原本設計的對話框用例（Dialog use-case）。
后來我們發(fā)現(xiàn)，雖然這個解析包對于對話框消息而言，解析速度完全夠用，但如果要解析更大篇幅的文章就顯得太慢了。
因此我決定要深入探索解決方案，并最終開發(fā)出了 NeuralCoref v3.0。這個版本比之前（每秒解析幾千字）的要快出百倍，同時還保證了相同的準確性，當然，它依然易于使用，也符合 Python 庫的生態(tài)環(huán)境。
在本篇文章中，我想向大家分享我在開發(fā) NeuralCoref v3.0 過程中學到的一些經(jīng)驗，尤其將涉及：
如何才能夠使用 Python 設計出一個高效率的模塊，
如何利用好 spaCy 的內(nèi)置數(shù)據(jù)結(jié)構，從而設計出超高效的自然語言處理函數(shù)。
我的標題其實有點作弊，因為我實際上要談論的是 Python，同時也要介紹一些 Cython 的特性。不過你知道嗎？Cython 屬于 Python 的超集，所以不要讓它嚇跑了！
小提示：你當前所編寫的 Python 項目已經(jīng)算是一個 Cython 項目了。
以下給出了一些可能需要采用這種加速策略的場景：
你正在使用 Python 給自然語言處理任務開發(fā)一個應用級模塊
你正在使用 Python 分析一個自然語言處理任務的大型數(shù)據(jù)集
你正在為諸如 PyTorch/TensoFlow 這些深度學習框架預處理大型訓練集，或者你的深度學習模型采用了處理邏輯復雜的批量加載器（Batch loader），它嚴重拖慢了你的訓練速度
提示：我還發(fā)布了一個 Jupyter notebook，其中包含了本文中討論的所有示例，歡迎大家下載調(diào)試！
你需要知道的第一件事情是，你的大部分代碼在純 Python 環(huán)境下可能都運行良好，但是其中存在一些瓶頸函數(shù)（Bottlenecks functions），一旦你能給予它們更多的「關照」，你的程序?qū)@得幾個數(shù)量級的提速。
所以你應該從剖析自己的 Python 代碼開始，找出那些低效模塊。其中一種方法就是使用 cProfile：
import cProfile
import pstats
import my_slow_module
cProfile.run('my_slow_module.run()', 'restats')
p = pstats.Stats('restats')
p.sort_stats('cumulative').print_stats(30)
你很可能會發(fā)現(xiàn)低效的原因是因為一些循環(huán)控制，或者你使用神經(jīng)網(wǎng)絡時引入了過多的 Numpy 數(shù)組操作（我不會花費時間在這里介紹 Numpy，這個問題已經(jīng)有太多文章進行了討論）。
那么我們該如何來加速循環(huán)呢？
讓我們通過一個簡單的例子來解決這個問題。假設有一堆矩形，我們將它們存儲成一個由 Python 對象（例如 Rectangle 對象實例）構成的列表。我們的模塊的主要功能是對該列表進行迭代運算，從而統(tǒng)計出有多少個矩形的面積是大于所設定閾值的。
我們的 Python 模塊非常簡單：
from random import random
class Rectangle:
def __init__(self, w, h):
self.w = w
self.h = h
def area(self):
return self.w * self.h
def check_rectangles(rectangles, threshold):
n_out = 0
for rectangle in rectangles:
if rectangle.area() > threshold:
n_out += 1
return n_out
def main():
n_rectangles = 10000000
rectangles = list(Rectangle(random(), random()) for i in range(n_rectangles))
n_out = check_rectangles(rectangles, threshold=0.25)
print(n_out)
其中 check_rectangles 函數(shù)就是我們程序的瓶頸！它對一個很長的 Python 對象列表進行迭代，而這一過程會相當緩慢，因為 Python 解釋器在每次迭代中都需要做很多工作（查找類中的 area 方法、參數(shù)的打包和解包、調(diào)用 Python API 等等）。
這時候該有請 Cython 出場幫助我們加速循環(huán)操作了。
Cython 語言是 Python 的一個超集，它包含有兩種類型的對象：
Python 對象就是我們在常規(guī) Python 中使用到的那些對象，諸如數(shù)值、字符串、列表和類實例等等
Cython C 對象就是那些 C 和 C++ 對象，諸如雙精度、整型、浮點數(shù)、結(jié)構和向量，它們能夠由 Cython 在超級高效的低級語言代碼中進行編譯
該循環(huán)只要采用 Cython 進行復現(xiàn)就能獲得更高的執(zhí)行速度，不過在 Cython 中我們只能夠操作 Cython C 對象。
定義這種循環(huán)最直接的一種方法就是，定義一個包含有計算過程中我們所需要用到的所有對象的結(jié)構體。具體而言，在本例中就是矩形的長度和寬度。
然后我們可以將矩形對象列表存儲到 C 的結(jié)構數(shù)組中，再將數(shù)組傳遞給 check_rectangles 函數(shù)。這個函數(shù)現(xiàn)在將接收一個 C 數(shù)組作為輸入，此外我們還使用 cdef 關鍵字取代了 def（注意：cdef 也可以用于定義 Cython C 對象）將函數(shù)定義為一個 Cython 函數(shù)。
這里是 Cython 版本的模塊程序：
from cymem.cymem cimport Pool
from random import random
cdef struct Rectangle:
float w
float h
cdef int check_rectangles(Rectangle* rectangles, int n_rectangles, float threshold):
cdef int n_out = 0
# C arrays contain no size information => we need to give it explicitly
for rectangle in rectangles[:n_rectangles]:
if rectangle[i].w * rectangle[i].h > threshold:
n_out += 1
return n_out
def main():
cdef:
int n_rectangles = 10000000
float threshold = 0.25
Pool mem = Pool()
Rectangle* rectangles = <Rectangle*>mem.alloc(n_rectangles, sizeof(Rectangle))
for i in range(n_rectangles):
rectangles[i].w = random()
rectangles[i].h = random()
n_out = check_rectangles(rectangles, n_rectangles, threshold)
print(n_out)
這里我們使用了原生的 C 數(shù)組指針，不過你還有其它選擇，特別是 C++ 中諸如向量、二元組、隊列這樣的結(jié)構體。在這段程序中，我還使用了一個來自 cymem 提供的 Pool() 內(nèi)存管理對象，它可以避免手動釋放所申請的 C 數(shù)組內(nèi)存空間。當不再需要使用 Pool 中的對象時，它將自動釋放該對象所占用的內(nèi)存空間。
補充：spaCy API 的 Cython 標準頁面提供了在實際應用中使用 Cython 實現(xiàn)自然語言處理任務的參考資料。
有很多辦法來測試、編譯和發(fā)布 Cython 代碼。Cython 甚至可以像 Python 一樣直接用于 Jupyter Notebook 中。
通過 pip install cython 命令安裝 Cython。
使用 %load_ext Cython 指令在 Jupyter notebook 中加載 Cython 擴展。
然后通過指令 %%cython，我們就可以像 Python 一樣在 Jupyter notebook 中使用 Cython。
如果在執(zhí)行 Cython 代碼的時候遇到了編譯錯誤，請檢查 Jupyter 終端的完整輸出信息。
大多數(shù)情況下可能都是因為在 %%cython 之后遺漏了 -+ 標簽（比如當你使用 spaCy Cython 接口時）。如果編譯器報出了關于 Numpy 的錯誤，那就是遺漏了 import numpy。
正如我在一開始就提到的，請好好閱讀這份 Jupyter notebook 和這篇文章，它包含了我們在 Jupyter 中討論到的所有示例。
Cython 代碼的文件后綴是 .pyx，這些文件將被 Cython 編譯器編譯成 C 或 C++ 文件，再進一步地被 C 編譯器編譯成字節(jié)碼文件。最終 Python 解釋器將能夠調(diào)用這些字節(jié)碼文件。
你也可以使用 pyximport 將一個 .pyx 文件直接加載到 Python 程序中：
>>> import pyximport; pyximport.install()
>>> import my_cython_module
你也可以將自己的 Cython 代碼作為 Python 包構建，然后像正常的 Python 包一樣將其導入或者發(fā)布，更多細節(jié)請參考這里。不過這種做法需要花費更多的時間，特別是你需要讓 Cython 包能夠在所有的平臺上運行。如果你需要一個參考樣例，不妨看看 spaCy 的安裝腳本。
在我們開始優(yōu)化自然語言處理任務之前，還是先快速介紹一下 def、cdef 和 cpdef 這三個關鍵字。它們是你開始學會使用 Cython 之前需要掌握的最主要的知識。
你可以在 Cython 程序中使用三種類型的函數(shù)：
Python 函數(shù)由 def 關鍵字定義，它的輸入和輸出都是 Python 對象。在函數(shù)內(nèi)可以使用 Python 和 C/C++ 對象，并且能夠調(diào)用 Cython 和 Python 函數(shù)。
Cython 函數(shù)由 cdef 關鍵字進行定義，它可以作為輸入對象，在函數(shù)內(nèi)部也可以操作或者輸出 Python 和 C/C++ 對象。這些函數(shù)不能從 Python 環(huán)境中訪問（即 Python 解釋器和其它可以導入 Cython 模塊的純 Python 模塊），但是可以由其它 Cython 模塊進行導入。
通過關鍵字 cpdef 定義的 Cython 函數(shù)與 cdef 定義的 Cython 函數(shù)很相似，但是 cpdef 定義的函數(shù)同時還提供了 Python 裝飾器，所以它們能夠在 Python 環(huán)境中被直接調(diào)用（函數(shù)采用 Python 對象作為輸入與輸出），此外也支持在 Cython 模塊中被調(diào)用（函數(shù)采用 C/C++ 或者 Python 對象作為輸入）。
cdef 關鍵字的另一個用途就是，在代碼中表明某一個對象是 Cython C/C++ 對象。所以除非你在代碼中使用 cdef 聲明對象，否則這些對象都會被解釋器當做 Python 對象（這會導致訪問速度變慢）。
這一切看起來都很好，但是......我們到現(xiàn)在都還沒開始涉及優(yōu)化自然語言處理任務！沒有字符串操作，沒有 unicode 編碼，也沒有我們在自然語言處理中所使用的妙招。
此外 Cython 的官方文檔甚至建議不要使用 C 語言類型的字符串：
通常來說：除非你明確地知道自己正在做什么，不然就該避免使用 C 類型字符串，而應該使用 Python 的字符串對象。
那么當我們在操作字符串時，要如何在 Cython 中設計一個更加高效的循環(huán)呢？
spaCy 引起了我們的注意力。
spaCy 處理該問題的做法就非常地明智。
spaCy 中所有的 unicode 字符串（一個標記的文本、它的小寫形式文本、它的引理形式、POS 標記標簽、解析樹依賴標簽、命名實體標簽等等）都被存儲在一個稱為 StringStore 的數(shù)據(jù)結(jié)構中，它通過一個 64 位哈希碼進行索引，例如 C 類型的 uint64_t。
StringStore 對象實現(xiàn)了 Python unicode 字符串與 64 位哈希碼之前的查找映射。
它可以從 spaCy 的任何地方和任意對象進行訪問，例如 npl.vocab.strings、doc.vocab.strings 或者 span.doc.vocab.string。
當某一個模塊需要在某些標記（tokens）上獲得更快的處理速度時，你可以使用 C 語言類型的 64 位哈希碼代替字符串來實現(xiàn)。調(diào)用 StringStore 查找表將返回與該哈希碼相關聯(lián)的 Python unicode 字符串。
但是 spaCy 能做的可不僅僅只有這些，它還允許我們訪問文檔和詞匯表完全填充的 C 語言類型結(jié)構，我們可以在 Cython 循環(huán)中使用這些結(jié)構，而不必去構建自己的結(jié)構。
與 spaCy 文檔有關的主要數(shù)據(jù)結(jié)構是 Doc 對象，該對象擁有經(jīng)過處理的字符串的標記序列（“words”）以及 C 語言類型對象中的所有標注，稱為 doc.c，它是一個 TokenC 的結(jié)構數(shù)組。
TokenC 結(jié)構包含了我們需要的關于每個標記的所有信息。這種信息被存儲成 64 位哈希碼，它可以與我們剛剛所見到的 unicode 字符串進行重新關聯(lián)。
如果想要準確地了解這些漂亮的 C 結(jié)構中的內(nèi)容，可以查看新建的 spaCy 的 Cython API 文檔。
接下來看一個簡單的自然語言處理的例子。
假設現(xiàn)在有一個文本文檔的數(shù)據(jù)集需要分析。
import urllib.request
import spacy
with urllib.request.urlopen('https://raw.githubusercontent.com/pytorch/examples/master/word_language_model/data/wikitext-2/valid.txt') as response:
text = response.read()
nlp = spacy.load('en')
doc_list = list(nlp(text[:800000].decode('utf8')) for i in range(10))
我寫了一個腳本用于創(chuàng)建一個包含有 10 份文檔的列表，每份文檔都大概含有 17 萬個單詞，采用 spaCy 進行分析。當然我們也可以對 17 萬份文檔（每份文檔包含 10 個單詞）進行分析，但是這樣做會導致創(chuàng)建的過程非常慢，所以我們還是選擇了 10 份文檔。
我們想要在這個數(shù)據(jù)集上展開某些自然語言處理任務。例如，我們可以統(tǒng)計數(shù)據(jù)集中單詞「run」作為名詞出現(xiàn)的次數(shù)（例如，被 spaCy 標記為「NN」詞性標簽）。
采用 Python 循環(huán)來實現(xiàn)上述分析過程非常簡單和直觀：
def slow_loop(doc_list, word, tag):
n_out = 0
for doc in doc_list:
for tok in doc:
if tok.lower_ == word and tok.tag_ == tag:
n_out += 1
return n_out
def main_nlp_slow(doc_list):
n_out = slow_loop(doc_list, 'run', 'NN')
print(n_out)
但是這個版本的代碼運行起來非常慢！這段代碼在我的筆記本上需要運行 1.4 秒才能獲得答案。如果我們的數(shù)據(jù)集中包含有數(shù)以百萬計的文檔，為了獲得答案，我們也許需要花費超過一天的時間。
我們也許能夠采用多線程來實現(xiàn)加速，但是在 Python 中這種做法并不是那么明智，因為你還需要處理全局解釋器鎖（GIL）。另外請注意，Cython 也可以使用多線程！Cython 在后臺可以直接調(diào)用 OpenMP。不過我沒有時間在這里討論并行性，所以請查看此鏈接以了解更多詳情。
現(xiàn)在讓我們嘗試使用 spaCy 和 Cython 來加速 Python 代碼。
首先需要考慮好數(shù)據(jù)結(jié)構，我們需要一個 C 類型的數(shù)組來存儲數(shù)據(jù)，需要指針來指向每個文檔的 TokenC 數(shù)組。我們還需要將測試字符（「run」和「NN」）轉(zhuǎn)成 64 位哈希碼。
當所有需要處理的數(shù)據(jù)都變成了 C 類型對象，我們就可以以純 C 語言的速度對數(shù)據(jù)集進行迭代。
這里展示了這個例子被轉(zhuǎn)換成 Cython 和 spaCy 的實現(xiàn)：
%%cython -+
import numpy # Sometime we have a fail to import numpy compilation error if we don't import numpy
from cymem.cymem cimport Pool
from spacy.tokens.doc cimport Doc
from spacy.typedefs cimport hash_t
from spacy.structs cimport TokenC
cdef struct DocElement:
TokenC* c
int length
cdef int fast_loop(DocElement* docs, int n_docs, hash_t word, hash_t tag):
cdef int n_out = 0
for doc in docs[:n_docs]:
for c in doc.c[:doc.length]:
if c.lex.lower == word and c.tag == tag:
n_out += 1
return n_out
def main_nlp_fast(doc_list):
cdef int i, n_out, n_docs = len(doc_list)
cdef Pool mem = Pool()
cdef DocElement* docs = <DocElement*>mem.alloc(n_docs, sizeof(DocElement))
cdef Doc doc
for i, doc in enumerate(doc_list): # Populate our database structure
docs[i].c = doc.c
docs[i].length = (<Doc>doc).length
word_hash = doc.vocab.strings.add('run')
tag_hash = doc.vocab.strings.add('NN')
n_out = fast_loop(docs, n_docs, word_hash, tag_hash)
print(n_out)
代碼有點長，因為我們必須在調(diào)用 Cython 函數(shù)之前在 main_nlp_fast 中聲明和填充 C 結(jié)構。
補充：如果你在代碼中需要多次使用低級結(jié)構，比每次填充 C 結(jié)構更優(yōu)雅的做法是，使用 C 類型結(jié)構的 Cython 擴展類型裝飾器來設計 Python 代碼。這就是大多數(shù) spaCy 代碼所采用的結(jié)構，它非常優(yōu)雅，兼具高效、低內(nèi)存花銷和易于訪問的特性。
這串代碼雖然變長了，但是運行效率卻更高！在我的 Jupyter notebook上，這串 Cython 代碼只運行了大概 20 毫秒，比之前的純 Python 循環(huán)快了大概 80 倍。
使用 Jupyter notebook 單元編寫模塊的速度很可觀，它可以與其它 Python 模塊和函數(shù)自然地連接：在 20 毫秒內(nèi)掃描大約 170 萬個單詞，這意味著我們每秒能夠處理高達 8 千萬個單詞。
對使用 Cython 進行自然語言處理加速的介紹到此為止，希望大家能喜歡它。
關于 Cython 還有很多其它的東西可以介紹，但是已經(jīng)超出了這篇文章的初衷（這篇文章只是作為簡介）。從現(xiàn)在開始，最好的資料也許是這份綜述性的 Cython 教程和介紹 spaCy 自然語言處理的 Cython 頁面。
如果你還想要獲得更多類似的內(nèi)容，請記得給我們點贊喲！
Via 100 Times Faster Natural Language Processing in Python，雷鋒網(wǎng) AI 研習社編譯整理
雷峰網(wǎng)版權文章，未經(jīng)授權禁止轉(zhuǎn)載。詳情見轉(zhuǎn)載須知。
