# 關(guān)注并星標(biāo)騰訊云開發(fā)者

(資料圖)

# 每周1 | 鵝廠工程師帶你審判技術(shù)

#第1期|李志瑞：AI 屆新語(yǔ)言 Mojo 要火？?

前段時(shí)間 Modular 發(fā)布了一個(gè)新語(yǔ)言 Mojo，這語(yǔ)言不止官網(wǎng)放了巨大的 emoji ?，而且它的標(biāo)準(zhǔn)文件后綴一個(gè)是「.mojo」另一個(gè)是「.?」，一副立馬要火的樣子呢。

說實(shí)話，這個(gè)用 emoji 做后綴名的操作其實(shí)挺無(wú)聊，也有點(diǎn)敗好感，但如果說這個(gè)語(yǔ)言能在完全兼容 Python 的基礎(chǔ)上大幅提高執(zhí)行效率，并且作者是 LLVM 發(fā)起人 Chris Lattner，是不是突然又有興趣繼續(xù)了解它了呢？

Mojo 被設(shè)計(jì)為 Python 語(yǔ)言的超集，并增加了許多特性，包括：

?? Progressive types：能利用類型信息獲得更好性能和靜態(tài)檢查，但又不強(qiáng)制要求寫類型。

?? Zero cost abstractions：C++ 的核心設(shè)計(jì)準(zhǔn)則，能夠避免用戶為了性能放棄合理設(shè)計(jì)的代碼。

?? Ownership + borrow checker：Rust 語(yǔ)言的安全性來(lái)源，在編譯期避免許多錯(cuò)誤的發(fā)生。

?? The full power of MLIR：原生支持對(duì) MLIR 的直接訪問，能夠從底層擴(kuò)展系統(tǒng)。

在 Mojo 這個(gè)語(yǔ)言的介紹中反復(fù)提到 AI，官網(wǎng)也說它是「a new programming language for all AI developers」。那么為什么 AI 開發(fā)需要一個(gè)新語(yǔ)言呢？首先，我們知道在 AI 屆具有統(tǒng)治地位的語(yǔ)言就是 Python，Python 是一個(gè)語(yǔ)法簡(jiǎn)單清晰，容易上手，且靈活度很高的語(yǔ)言，深受廣大程序員喜愛，XKCD 上有就這么一幅漫畫：

當(dāng)然，受人喜愛的語(yǔ)言有很多，Python 成為 AI 屆的統(tǒng)治語(yǔ)言除了本身易用之外，也有慣性的因素。由于 Python 上機(jī)器學(xué)習(xí)相關(guān)的庫(kù)多，因此機(jī)器學(xué)習(xí)從業(yè)者用的就多，這又反過來(lái)令新的機(jī)器學(xué)習(xí)相關(guān)庫(kù)優(yōu)先為 Python 提供接口，進(jìn)一步加強(qiáng)了其統(tǒng)治地位。因此，為了逐步滲透這個(gè)用戶群，Mojo 兼容 Python 是很正確的一個(gè)選擇。Mojo 不僅承諾語(yǔ)法是 Python 的超集，并且它還能直接調(diào)用 Python 的庫(kù)，這意味著 Mojo 不需要從零開始構(gòu)建自己的生態(tài)，本身就可以用上繁榮的 Python 生態(tài)了。

雖然 Python 很好，但它有一個(gè)眾所周知的問題，那就是太慢了。而機(jī)器學(xué)習(xí)本身又需要繁重的計(jì)算，因此 Python 生態(tài)中大量庫(kù)的底層其實(shí)都是用高性能的語(yǔ)言（如 C/C++）進(jìn)行實(shí)現(xiàn)，然后再提供一個(gè) Python 接口供用戶調(diào)用，典型的如 numpy 這種數(shù)學(xué)庫(kù)。在這種情況下，Python 事實(shí)上是被作為一個(gè)膠水語(yǔ)言來(lái)使用，這造成了開發(fā)的碎片化，如果一個(gè)用戶只是簡(jiǎn)單調(diào)一下庫(kù)那還好說，但一旦到了工業(yè)界，開發(fā)過程中不可避免地就要涉及一些底層庫(kù)的修改，甚至直接換語(yǔ)言來(lái)實(shí)現(xiàn)同樣的功能以提高性能，這種割裂不止增加了開發(fā)成本和精神負(fù)擔(dān)，而且考慮到眾多擅長(zhǎng) C/C++ 語(yǔ)言的開發(fā)者也并不是 AI 領(lǐng)域?qū)＜遥@種開發(fā)人員能力的不適配也對(duì)整個(gè) AI 生態(tài)的發(fā)展形成了一定阻礙。

因此，Mojo 的目的就是要在 Python 生態(tài)的基礎(chǔ)上，讓用戶能用一個(gè)語(yǔ)言，從使用易用的接口，到開發(fā)復(fù)雜的庫(kù)，再到實(shí)現(xiàn)底層黑科技，統(tǒng)一實(shí)驗(yàn)和生產(chǎn)環(huán)境所用的語(yǔ)言。為了實(shí)現(xiàn)這個(gè)目的，Mojo 擴(kuò)展了 Python 語(yǔ)法，支持了緊湊的內(nèi)存布局，并引入了一些現(xiàn)代的語(yǔ)言特性（例如 Rust 的安全性檢查），使得這個(gè)語(yǔ)言能夠漸進(jìn)式地在 AI 界立足。說起來(lái) Chris Lattner 在這方面可以算是經(jīng)驗(yàn)豐富了，不管是在 gcc/msvc 的統(tǒng)治下實(shí)現(xiàn) clang，還是在 objective-c 的統(tǒng)治下為蘋果實(shí)現(xiàn) swift，都是一個(gè)逐步蠶食對(duì)手市場(chǎng)的過程。

說了這么多，該來(lái)看看 Mojo 長(zhǎng)什么樣了。現(xiàn)在 Mojo 還不能直接下載使用，如果想要嘗鮮，需要在官網(wǎng)申請(qǐng)，然后在 playground 頁(yè)面中試用，這是一個(gè)基于 Jupyter 的頁(yè)面，可以混合筆記和可執(zhí)行的 Mojo 代碼。

前面提到，Mojo 的語(yǔ)法是 Python 的超集，因此 Mojo 的 Hello World 也跟 Python 一樣簡(jiǎn)單：

print("Hello World") #> Hello World

與 Python 一樣，Mojo 也使用換行符和縮進(jìn)來(lái)定義代碼塊：

fn foo():var x: Int = 1x += 1let y: Int = 1print(x, y)  #> 2 1foo()

上面的代碼中使用 var 來(lái)聲明變量 x，使用 let 來(lái)聲明了不可變量 y。Mojo 像很多較新近的語(yǔ)言一樣，讓不可變量的聲明變得簡(jiǎn)單，以鼓勵(lì)開發(fā)者使用不可變的量。另外注意到這里定義函數(shù)使用了 fn 而非 Python 的 def，這是因?yàn)?Mojo 希望在兼容 Python 的基礎(chǔ)上加入編譯期的檢查和優(yōu)化，而 Python 過于動(dòng)態(tài)的語(yǔ)法很難支持這一目標(biāo)，因此，Mojo 同時(shí)支持使用 fn 和 def 兩個(gè)關(guān)鍵字來(lái)聲明函數(shù)，對(duì)于調(diào)用者來(lái)說，這兩種方法聲明出來(lái)的函數(shù)沒有什么區(qū)別，但對(duì)于實(shí)現(xiàn)者來(lái)說，可以將 fn 看作「嚴(yán)格模式」下的 def，例如下面的代碼會(huì)編譯錯(cuò)誤（如果改成用 def 則不會(huì)出錯(cuò)）：

fn foo(): x = 1 print(x) #error:Expression[12]:6:5:useofunknowndeclaration"x","fn"declarationsrequireexplicitvariabledeclarations#x=1#^

雖然官方承諾 Mojo 的語(yǔ)法是 Python 的超集，但目前 Mojo 還在開發(fā)中，很多 Python 語(yǔ)法都還不支持，例如目前連 Python 的 class 都無(wú)法被編譯通過：

class MyClass:def foo():pass# error: Expression [15]:17:5: classes are not supported yet#     class MyClass:#     ^

不過，Mojo 現(xiàn)在先提供了另一個(gè)用來(lái)組織數(shù)據(jù)的關(guān)鍵字 struct，相比于 class，struct 更加靜態(tài)可控，便于優(yōu)化。一方面，struct 支持類似 Python class 風(fēng)格的函數(shù)聲明和運(yùn)算符重載。而另一方面，struct 又類似于 C++ 的 struct 和 class，內(nèi)部的成員在內(nèi)存中緊湊排布，而且不支持在運(yùn)行時(shí)動(dòng)態(tài)添加成員和方法，便于編譯期進(jìn)行優(yōu)化，例如：

struct MyIntPair:var first: Intvar second: Intfn __init__(inout self, first: Int, second: Int):self.first = firstself.second = secondfn __lt__(self, rhs: MyIntPair) -> Bool:return self.first < rhs.first or(self.first == rhs.first andself.second < rhs.second)let p1 = MyIntPair(1, 2)let p2 = MyIntPair(2, 1)if p1 < p2: print("p1 < p2")  #> p1 < p2

雖然有點(diǎn)不同，但整體上看起來(lái)還是非常熟悉的對(duì)吧。說到這里，有一點(diǎn)需要提醒各位注意，盡管 Mojo 之后會(huì)令語(yǔ)法成為 Python 語(yǔ)法的超集，但其語(yǔ)義則有時(shí)會(huì)和 Python 不同，這意味著 Python 的代碼直接拷到 Mojo 里可能會(huì)出現(xiàn)編譯通過但執(zhí)行結(jié)果不同的情況，這里簡(jiǎn)單提一個(gè)比較常見的例子：函數(shù)傳參。在 Python 中，函數(shù)傳參的語(yǔ)義類似于 C++ 的傳指針，在函數(shù)內(nèi)部雖然不能更改調(diào)用者指向的對(duì)象，但可以改變?cè)搶?duì)象內(nèi)部的狀態(tài)，例如下面的代碼：

def foo(lst):lst[0] = 5print(lst)x = [1, 2, 3]foo(x)print(x)

在 Python 中，這段代碼打印出來(lái)的結(jié)果是兩次 [5, 2, 3]。但在 Mojo 中，使用 def 定義的函數(shù)默認(rèn)的傳遞邏輯是復(fù)制值，也就是說，盡管在函數(shù)中能夠修改參數(shù)內(nèi)部的狀態(tài)，但修改對(duì)于調(diào)用方來(lái)說是不可見的，因此上面這段代碼在 Mojo 中打印的結(jié)果是 [5, 2, 3]（foo 內(nèi)部）和 [1, 2, 3]（foo 外部）。

除了語(yǔ)法像 Python，Mojo 非常務(wù)實(shí)的一點(diǎn)在于它構(gòu)建于 Python 的生態(tài)之上。因此即便 Mojo 還沒能完整支持 Python 的語(yǔ)法，它還是優(yōu)先支持了對(duì) Python 庫(kù)的調(diào)用，以便讓開發(fā)者能受益于龐大完善的 Python 的生態(tài)。例如下面的代碼就使用了 Python 的 numpy 庫(kù)：

fromPythonInterfaceimportPythonlet np = Python.import_module("numpy")ar = np.arange(15).reshape(3, 5)print(ar.shape)   #> (3, 5)

Mojo 作為一個(gè)新語(yǔ)言，廣泛吸收許多現(xiàn)代的程序語(yǔ)言設(shè)計(jì)思想，例如 Rust 的所有權(quán)和借用檢查，以此提升代碼的安全性。在 Mojo 中，使用 fn 定義的函數(shù)的參數(shù)默認(rèn)傳的是不可變的引用，即「借用」，調(diào)用方仍然擁有其所有權(quán)，因此在函數(shù)內(nèi)部不可以對(duì)參數(shù)進(jìn)行修改。Mojo 提供了一個(gè) borrow 關(guān)鍵字來(lái)標(biāo)注這樣的參數(shù)傳遞情況，對(duì)于 fn 來(lái)說是可以省略的，也就是說下面 foo 函數(shù)中兩個(gè)參數(shù)的傳遞方式相同：

fn foo(borrowed a: SomethingBig, b: SomethingBig):a.use()b.use()

在 Rust 中，傳參的默認(rèn)行為是移動(dòng)，如果需要借用則需要在傳入時(shí)加上 &，這兩種方式倒是沒有太大的優(yōu)劣之分，Mojo 的行為可能更接近于 Python 這類高級(jí)語(yǔ)言的習(xí)慣。如果想要修改傳入的參數(shù)，則需要手動(dòng)注明 inout，例如：

fn swap(inout lhs: Int, inout rhs: Int):let tmp = lhslhs = rhsrhs = tmpfn test_swap():var x = 42var y = 12print(x, y)  #> 42, 12swap(x, y)print(x, y)  #> 12, 42test_swap()

按道理說，Mojo 應(yīng)該像 Rust 一樣規(guī)避一個(gè)變量同時(shí)被可變和不可變借用，也應(yīng)該規(guī)避同時(shí)被可變借用，但目前 Mojo 編譯器似乎還沒實(shí)現(xiàn)這一特性，例如下面的代碼還是能編譯通過的：

var x = 42swap(x,x)

從這也可以看出 Mojo 確實(shí)還處在比較早期的發(fā)展階段。

另一個(gè)重要的內(nèi)存安全概念是對(duì)象的所有權(quán)，當(dāng)一個(gè)函數(shù)獲取了對(duì)象的所有權(quán)后，調(diào)用方就不應(yīng)該再去使用這個(gè)對(duì)象了，例如我們實(shí)現(xiàn)了一個(gè)只支持移動(dòng)的類型 UniquePtr：

struct UniquePtr:var ptr: Intfn __init__(inout self, ptr: Int):self.ptr = ptrfn __moveinit__(inout self, owned existing: Self):self.ptr = existing.ptrfn __del__(owned self):self.ptr = 0

同時(shí)，我們有兩個(gè)函數(shù)，其中，use_ptr 使用了前面提到的 borrow 關(guān)鍵字，借用了 UniquePtr 對(duì)象，而 take_ptr 則使用 owned 關(guān)鍵字，指明它需要獲取傳入對(duì)象的所有權(quán)。那么，在調(diào)用 take_ptr 的時(shí)候，我們就需要在參數(shù)后面加上 ^ 后綴，用來(lái)表明我們將所有權(quán)轉(zhuǎn)移給 take_ptr：

fn use_ptr(borrowed p: UniquePtr):print(p.ptr)fn take_ptr(owned p: UniquePtr):print(p.ptr)fn test_ownership():let p = UniquePtr(100)use_ptr(p)    #> 100take_ptr(p^)  #> 100test_ownership()

因此，如果我們將 use_ptr 和 take_ptr 的調(diào)用順序調(diào)換一下，就會(huì)出現(xiàn)編譯錯(cuò)誤：

fn test_ownership():let p = UniquePtr(100)take_ptr(p^)use_ptr(p)    # ERROR!test_ownership()# error: Expression [13]:23:12: use of uninitialized value "p"#    use_ptr(p) # ERROR: p is no longer valid here!#            ^

Mojo 的另一個(gè)強(qiáng)大之處在于它讓對(duì) MLIR>) 的操作變得更簡(jiǎn)單。MLIR 全稱是 Multi-Level Intermediate Representation，是一個(gè)編譯器開發(fā)框架，它存在的目的是通過定義多種方言來(lái)逐級(jí)將代碼轉(zhuǎn)換為機(jī)器碼，以降低編譯器的開發(fā)成本。在 MLIR 之前，一個(gè)廣為人熟知的 IR 是 LLVM IR，一個(gè)語(yǔ)言的編譯器作者可以通過將自己的語(yǔ)言編譯為 LLVM IR 來(lái)接入 LLVM 的工具鏈，使得編譯器作者不需要關(guān)心底層具體硬件的差別，實(shí)現(xiàn)了對(duì)底層編譯工具鏈的復(fù)用：

但 LLVM IR 層級(jí)過低，難以進(jìn)行特定于語(yǔ)言本身的優(yōu)化，從上面的圖中也能看出，各個(gè)語(yǔ)言為了實(shí)現(xiàn)語(yǔ)言本身的優(yōu)化，都在編譯為 LLVM IR 之前加入了自己的 IR。另外 LLVM IR 擴(kuò)展起來(lái)也非常困難，難以適應(yīng)復(fù)雜異構(gòu)計(jì)算的要求，而異構(gòu)計(jì)算在 AI 開發(fā)中又非常普遍。MLIR 相比于之前的 IR，更加模塊化，僅保留了一個(gè)非常小的內(nèi)核，方便開發(fā)者進(jìn)行擴(kuò)展。很多編譯器將代碼編譯為 MLIR，而 Mojo 提供了直接訪問 MLIR 的能力，這使得 Mojo 能夠受益于這些工具。更多關(guān)于 MLIR 的內(nèi)容可以參考這一系列文章：編譯器與中間表示: LLVM IR, SPIR-V, 以及 MLIR，這里就不做過多贅述，我們主要關(guān)注在 Mojo 中可以如何操作 MLIR。舉例而言，如果我們希望實(shí)現(xiàn)一個(gè)新的 boolean 類型 OurBool，我們可以這樣實(shí)現(xiàn)：

alias OurTrue: OurBool = __mlir_attr.`true`alias OurFalse: OurBool = __mlir_attr.`false`@register_passable("trivial")struct OurBool:var value: __mlir_type.i1fn __init__() -> Self:return OurFalsefn __init__(value: __mlir_type.i1) -> Self:return Self {value: value}fn __bool__(self) -> Bool:return Bool(self.value)

這里定義了一個(gè)類型為 OurBool 的類型，里面有一個(gè)直接使用 MLIR 內(nèi)置類型 i1 的成員 value 。在 Mojo 中，我們可以通過 __mlir_type.typename 的形式來(lái)訪問 MLIR 類型。接著，我們?yōu)檫@個(gè)類型提供了兩個(gè)構(gòu)造函數(shù)，默認(rèn)情況下構(gòu)造為 OurFalse 也可基于傳入的參數(shù)進(jìn)行構(gòu)建。最下面的 __bool__ 也和 Python 的 __bool__ 一樣，用于使該類型具有和內(nèi)置 boolean 類型的性質(zhì)，此時(shí)我們可以這樣使用它：

let t: OurBool = OurTrueif t: print("true")  #> true

除了使用 MLIR 之外，Mojo 甚至可以允許開發(fā)者使用 MLIR 實(shí)現(xiàn)邏輯，例如下面的代碼中通過應(yīng)用 MLIR 的 index.casts 操作來(lái)實(shí)現(xiàn)類型轉(zhuǎn)換，然后再通過 index.cmp 對(duì)值進(jìn)行比較：

# ...struct OurBool:# ...fn __eq__(self, rhs: OurBool) -> Self:let lhsIndex = __mlir_op.`index.casts`[_type : __mlir_type.index](self.value)let rhsIndex = __mlir_op.`index.casts`[_type : __mlir_type.index](rhs.value)return Self(__mlir_op.`index.cmp`[pred : __mlir_attr.`#index`](lhsIndex, rhsIndex))

基于封裝好的 __eq__ 方法，我們可以很容易實(shí)現(xiàn) __invert__ 方法：

# ...struct OurBool:# ...fn __invert__(self) -> Self:return OurFalse if self == OurTrue else OurTrue

此時(shí)，我們就可以對(duì) OurBool 類型的對(duì)象使用 ~ 操作符了：

let f = OurFalseif ~f: print("false")  #> false

通過這個(gè)簡(jiǎn)單的例子我們可以看出，在 Mojo 中，開發(fā)者可以通過訪問 MLIR 來(lái)實(shí)現(xiàn)和內(nèi)置類型同等高效的類型。這使得開發(fā)者可以在 Mojo 上為新硬件的數(shù)據(jù)類型封裝高效簡(jiǎn)單的 Mojo 接口而不需要切換語(yǔ)言。雖然大部分開發(fā)者并不需要接觸 MLIR，但 Mojo 為更深入和更底層的優(yōu)化提供了充分的可能性。

雖然 Mojo 反復(fù)強(qiáng)調(diào)它是為 AI 設(shè)計(jì)的新語(yǔ)言，但以目前 Mojo 的設(shè)計(jì)方向來(lái)看，它的發(fā)展前景并不止于 AI。本質(zhì)上 Mojo 提供了一個(gè)能夠兼容 Python 生態(tài)的高性能語(yǔ)言，且這個(gè)語(yǔ)言可以讓 Python 開發(fā)者幾乎無(wú)痛地切換過去，那 Python 開發(fā)者何樂而不為呢？對(duì)于使用 Mojo 的開發(fā)者來(lái)說，上層業(yè)務(wù)可以將 Mojo 當(dāng) Python 一樣使用，享受到簡(jiǎn)明的語(yǔ)法帶來(lái)的高開發(fā)效率，當(dāng)出現(xiàn)性能瓶頸的時(shí)候，也不用切換語(yǔ)言去進(jìn)行優(yōu)化，直接使用 Mojo 重構(gòu)模塊即可。雖然現(xiàn)在還沒法在生產(chǎn)環(huán)境中驗(yàn)證這個(gè)想法，但這個(gè)未來(lái)聽起來(lái)確實(shí)非常美好。關(guān)于 Mojo 和 Python 開發(fā)性能的對(duì)比，您可瀏覽 Mojo 發(fā)布會(huì)上的 Jeremy Howard demo for Mojo launch 視頻。

目前 Mojo 還在比較早期的階段，不僅許多語(yǔ)言特性都還沒實(shí)現(xiàn)，而且連本地開發(fā)的套件都沒有提供。不過其發(fā)展路線和設(shè)計(jì)思路都非常務(wù)實(shí) ，又有一個(gè)足夠?qū)I(yè)的領(lǐng)導(dǎo)者和公司作為背景支撐，可以說是未來(lái)可期，也非常希望這個(gè)語(yǔ)言能在其他領(lǐng)域得到更廣泛的應(yīng)用。

關(guān)鍵詞：