雷鋒網 AI 研習社按：本文的作者是來自 Hugging face 的科學家 Thomas Wolf，他的研究方向包括機器學習、自然語言處理和深度學習。在這篇博客中，他介紹了如何利用 Cython 和 spaCy 讓 Python 在自然語言處理任務中獲得百倍加速。雷鋒網 AI 研習社根據原文進行了編譯。
SpaceX 獵鷹重型發射器，版權歸 SpaceX 所有
提示：本文中涉及的所有例子都可以在這個 Jupyter notebook 中獲得源碼。
在去年我們發布了用 Python 實現的基於神經網絡的相互引用解析包（Neural coreference resolution package）之後，在社區中獲得了驚人數量的反饋，許多人開始將該解析包用到各種各樣的應用中，有一些應用場景甚至已經超出了我們原本設計的對話框用例（Dialog use-case）。
後來我們發現，雖然這個解析包對於對話框消息而言，解析速度完全夠用，但如果要解析更大篇幅的文章就顯得太慢了。
因此我決定要深入探索解決方案，並最終開發出了 NeuralCoref v3.0。這個版本比之前（每秒解析幾千字）的要快出百倍，同時還保證了相同的準確性，當然，它依然易於使用，也符合 Python 庫的生態環境。
在本篇文章中，我想向大家分享我在開發 NeuralCoref v3.0 過程中學到的一些經驗，尤其將涉及：
我的標題其實有點作弊，因為我實際上要談論的是 Python，同時也要介紹一些 Cython 的特性。不過你知道嗎？Cython 屬於 Python 的超集，所以不要讓它嚇跑了！
小提示：你當前所編寫的 Python 項目已經算是一個 Cython 項目了。
以下給出了一些可能需要採用這種加速策略的場景：
你正在使用 Python 給自然語言處理任務開發一個應用級模塊
你正在使用 Python 分析一個自然語言處理任務的大型數據集
你正在為諸如 PyTorch/TensoFlow 這些深度學習框架預處理大型訓練集，或者你的深度學習模型採用了處理邏輯複雜的批量加載器（Batch loader），它嚴重拖慢了你的訓練速度
提示：我還發布了一個 Jupyter notebook，其中包含了本文中討論的所有示例，歡迎大家下載調試！
百倍加速第一步：代碼剖析你需要知道的第一件事情是，你的大部分代碼在純 Python 環境下可能都運行良好，但是其中存在一些瓶頸函數（Bottlenecks functions），一旦你能給予它們更多的「關照」，你的程序將獲得幾個數量級的提速。
所以你應該從剖析自己的 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)
你很可能會發現低效的原因是因為一些循環控制，或者你使用神經網絡時引入了過多的 Numpy 數組操作（我不會花費時間在這裡介紹 Numpy，這個問題已經有太多文章進行了討論）。
那麼我們該如何來加速循環呢？
在 Pyhthon 中加入 Cython 加速循環計算讓我們通過一個簡單的例子來解決這個問題。假設有一堆矩形，我們將它們存儲成一個由 Python 對象（例如 Rectangle 對象實例）構成的列表。我們的模塊的主要功能是對該列表進行迭代運算，從而統計出有多少個矩形的面積是大於所設定閾值的。
我們的 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 函數就是我們程序的瓶頸！它對一個很長的 Python 對象列表進行迭代，而這一過程會相當緩慢，因為 Python 解釋器在每次迭代中都需要做很多工作（查找類中的 area 方法、參數的打包和解包、調用 Python API 等等）。
這時候該有請 Cython 出場幫助我們加速循環操作了。
Cython 語言是 Python 的一個超集，它包含有兩種類型的對象：
該循環只要採用 Cython 進行復現就能獲得更高的執行速度，不過在 Cython 中我們只能夠操作 Cython C 對象。
定義這種循環最直接的一種方法就是，定義一個包含有計算過程中我們所需要用到的所有對象的結構體。具體而言，在本例中就是矩形的長度和寬度。
然後我們可以將矩形對象列表存儲到 C 的結構數組中，再將數組傳遞給 check_rectangles 函數。這個函數現在將接收一個 C 數組作為輸入，此外我們還使用 cdef 關鍵字取代了 def（注意：cdef 也可以用於定義 Cython C 對象）將函數定義為一個 Cython 函數。
這裡是 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 數組指針，不過你還有其它選擇，特別是 C++ 中諸如向量、二元組、隊列這樣的結構體。在這段程序中，我還使用了一個來自 cymem 提供的 Pool() 內存管理對象，它可以避免手動釋放所申請的 C 數組內存空間。當不再需要使用 Pool 中的對象時，它將自動釋放該對象所佔用的內存空間。
補充：spaCy API 的 Cython 標準頁面提供了在實際應用中使用 Cython 實現自然語言處理任務的參考資料。
讓我們開始動手吧！有很多辦法來測試、編譯和發布 Cython 代碼。Cython 甚至可以像 Python 一樣直接用於 Jupyter Notebook 中。
通過 pip install cython 命令安裝 Cython。
首先在 Jupyter 中進行測試使用 %load_ext Cython 指令在 Jupyter notebook 中加載 Cython 擴展。
然後通過指令 %%cython，我們就可以像 Python 一樣在 Jupyter notebook 中使用 Cython。
如果在執行 Cython 代碼的時候遇到了編譯錯誤，請檢查 Jupyter 終端的完整輸出信息。
大多數情況下可能都是因為在 %%cython 之後遺漏了 -+ 標籤（比如當你使用 spaCy Cython 接口時）。如果編譯器報出了關於 Numpy 的錯誤，那就是遺漏了 import numpy。
正如我在一開始就提到的，請好好閱讀這份 Jupyter notebook 和這篇文章，它包含了我們在 Jupyter 中討論到的所有示例。
編寫、使用和發布 Cython 代碼Cython 代碼的文件後綴是 .pyx，這些文件將被 Cython 編譯器編譯成 C 或 C++ 文件，再進一步地被 C 編譯器編譯成字節碼文件。最終 Python 解釋器將能夠調用這些字節碼文件。
你也可以使用 pyximport 將一個 .pyx 文件直接加載到 Python 程序中：
>>> import pyximport; pyximport.install()
>>> import my_cython_module
你也可以將自己的 Cython 代碼作為 Python 包構建，然後像正常的 Python 包一樣將其導入或者發布，更多細節請參考這裡。不過這種做法需要花費更多的時間，特別是你需要讓 Cython 包能夠在所有的平臺上運行。如果你需要一個參考樣例，不妨看看 spaCy 的安裝腳本。
在我們開始優化自然語言處理任務之前，還是先快速介紹一下 def、cdef 和 cpdef 這三個關鍵字。它們是你開始學會使用 Cython 之前需要掌握的最主要的知識。
你可以在 Cython 程序中使用三種類型的函數：
Python 函數由 def 關鍵字定義，它的輸入和輸出都是 Python 對象。在函數內可以使用 Python 和 C/C++ 對象，並且能夠調用 Cython 和 Python 函數。
Cython 函數由 cdef 關鍵字進行定義，它可以作為輸入對象，在函數內部也可以操作或者輸出 Python 和 C/C++ 對象。這些函數不能從 Python 環境中訪問（即 Python 解釋器和其它可以導入 Cython 模塊的純 Python 模塊），但是可以由其它 Cython 模塊進行導入。
通過關鍵字 cpdef 定義的 Cython 函數與 cdef 定義的 Cython 函數很相似，但是 cpdef 定義的函數同時還提供了 Python 裝飾器，所以它們能夠在 Python 環境中被直接調用（函數採用 Python 對象作為輸入與輸出），此外也支持在 Cython 模塊中被調用（函數採用 C/C++ 或者 Python 對象作為輸入）。
cdef 關鍵字的另一個用途就是，在代碼中表明某一個對象是 Cython C/C++ 對象。所以除非你在代碼中使用 cdef 聲明對象，否則這些對象都會被解釋器當做 Python 對象（這會導致訪問速度變慢）。
使用 Cython 和 spaCy 加速自然語言處理這一切看起來都很好，但是......我們到現在都還沒開始涉及優化自然語言處理任務！沒有字符串操作，沒有 unicode 編碼，也沒有我們在自然語言處理中所使用的妙招。
此外 Cython 的官方文檔甚至建議不要使用 C 語言類型的字符串：
通常來說：除非你明確地知道自己正在做什麼，不然就該避免使用 C 類型字符串，而應該使用 Python 的字符串對象。
那麼當我們在操作字符串時，要如何在 Cython 中設計一個更加高效的循環呢？
spaCy 引起了我們的注意力。
spaCy 處理該問題的做法就非常地明智。
將所有的字符串轉換為 64 位哈希碼spaCy 中所有的 unicode 字符串（一個標記的文本、它的小寫形式文本、它的引理形式、POS 標記標籤、解析樹依賴標籤、命名實體標籤等等）都被存儲在一個稱為 StringStore 的數據結構中，它通過一個 64 位哈希碼進行索引，例如 C 類型的 uint64_t。
StringStore 對象實現了 Python unicode 字符串與 64 位哈希碼之前的查找映射。
它可以從 spaCy 的任何地方和任意對象進行訪問，例如 npl.vocab.strings、doc.vocab.strings 或者 span.doc.vocab.string。
當某一個模塊需要在某些標記（tokens）上獲得更快的處理速度時，你可以使用 C 語言類型的 64 位哈希碼代替字符串來實現。調用 StringStore 查找表將返回與該哈希碼相關聯的 Python unicode 字符串。
但是 spaCy 能做的可不僅僅只有這些，它還允許我們訪問文檔和詞彙表完全填充的 C 語言類型結構，我們可以在 Cython 循環中使用這些結構，而不必去構建自己的結構。
SpaCy 的內部數據結構與 spaCy 文檔有關的主要數據結構是 Doc 對象，該對象擁有經過處理的字符串的標記序列（「words」）以及 C 語言類型對象中的所有標註，稱為 doc.c，它是一個 TokenC 的結構數組。
TokenC 結構包含了我們需要的關於每個標記的所有信息。這種信息被存儲成 64 位哈希碼，它可以與我們剛剛所見到的 unicode 字符串進行重新關聯。
如果想要準確地了解這些漂亮的 C 結構中的內容，可以查看新建的 spaCy 的 Cython API 文檔。
接下來看一個簡單的自然語言處理的例子。
更快的自然語言處理假設現在有一個文本文檔的數據集需要分析。
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))
我寫了一個腳本用於創建一個包含有 10 份文檔的列表，每份文檔都大概含有 17 萬個單詞，採用 spaCy 進行分析。當然我們也可以對 17 萬份文檔（每份文檔包含 10 個單詞）進行分析，但是這樣做會導致創建的過程非常慢，所以我們還是選擇了 10 份文檔。
我們想要在這個數據集上展開某些自然語言處理任務。例如，我們可以統計數據集中單詞「run」作為名詞出現的次數（例如，被 spaCy 標記為「NN」詞性標籤）。
採用 Python 循環來實現上述分析過程非常簡單和直觀：
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 秒才能獲得答案。如果我們的數據集中包含有數以百萬計的文檔，為了獲得答案，我們也許需要花費超過一天的時間。
我們也許能夠採用多線程來實現加速，但是在 Python 中這種做法並不是那麼明智，因為你還需要處理全局解釋器鎖（GIL）。另外請注意，Cython 也可以使用多線程！Cython 在後臺可以直接調用 OpenMP。不過我沒有時間在這裡討論並行性，所以請查看此連結以了解更多詳情。
現在讓我們嘗試使用 spaCy 和 Cython 來加速 Python 代碼。
首先需要考慮好數據結構，我們需要一個 C 類型的數組來存儲數據，需要指針來指向每個文檔的 TokenC 數組。我們還需要將測試字符（「run」和「NN」）轉成 64 位哈希碼。
當所有需要處理的數據都變成了 C 類型對象，我們就可以以純 C 語言的速度對數據集進行迭代。
這裡展示了這個例子被轉換成 Cython 和 spaCy 的實現：
%%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)
代碼有點長，因為我們必須在調用 Cython 函數之前在 main_nlp_fast 中聲明和填充 C 結構。
補充：如果你在代碼中需要多次使用低級結構，比每次填充 C 結構更優雅的做法是，使用 C 類型結構的 Cython 擴展類型裝飾器來設計 Python 代碼。這就是大多數 spaCy 代碼所採用的結構，它非常優雅，兼具高效、低內存花銷和易於訪問的特性。
這串代碼雖然變長了，但是運行效率卻更高！在我的 Jupyter notebook上，這串 Cython 代碼只運行了大概 20 毫秒，比之前的純 Python 循環快了大概 80 倍。
使用 Jupyter notebook 單元編寫模塊的速度很可觀，它可以與其它 Python 模塊和函數自然地連接：在 20 毫秒內掃描大約 170 萬個單詞，這意味著我們每秒能夠處理高達 8 千萬個單詞。
對使用 Cython 進行自然語言處理加速的介紹到此為止，希望大家能喜歡它。
關於 Cython 還有很多其它的東西可以介紹，但是已經超出了這篇文章的初衷（這篇文章只是作為簡介）。從現在開始，最好的資料也許是這份綜述性的 Cython 教程和介紹 spaCy 自然語言處理的 Cython 頁面。
如果你還想要獲得更多類似的內容，請記得給我們點讚喲！
Via 100 Times Faster Natural Language Processing in Python，雷鋒網(公眾號：雷鋒網) AI 研習社編譯整理
雷鋒網版權文章，未經授權禁止轉載。詳情見轉載須知。