TL; DR：使用TensorFlow作為數據流程序的分布式計算框架，我們通過聯網實現了SPDZ協議的全面實施，從而實現了對加密數據的優化機器學習。

與之前我們關注安全計算背后的概念以及潛在的應用程序不同?，我們在這里構建了一個完全正常工作（被動安全）的實現，其中運行在不同機器上的玩家以及通過典型網絡堆棧進行通信。?作為其中的一部分，我們研究了在實驗安全計算時使用現代分布式計算平臺的好處，而不是從頭開始構建一切。

此外，這也可以看作是將私人機器學習掌握在從業者手中的一個步驟，與TensorFlow等現有和流行工具的集成起著重要作用。?具體而言，雖然我們這里只做了一個相對較淺的集成，但沒有使用TensorFlow附帶的一些強大的工具（例如自動分化?），但我們確實展示了如何克服基本的技術障礙，為更深入的研究鋪平道路集成。

向前看，回想起來，TensorFlow是一個明顯的候選框架，可以快速嘗試安全計算協議，至少在私人機器學習的背景下。

所有代碼都可以在本地或在Google Cloud上使用?。?為了簡單起見，我們運行的示例始終是使用邏輯?回歸的私人預測，這意味著給定一個私有的（即加密的）輸入x我們希望安全地為私有但預先訓練的權重計算sigmoid(dot(w, x) + b)?w和偏見b?（?w和b私人培訓被視為后續職位）。?實驗表明，對于具有100個特征的模型，這可以在TensorFlow中完成，延遲低至60ms，速率高達每秒20,000個預測。

非常感謝Andrew Trask?，?Kory Mathewson?，?Jan?Leike和OpenMined社區為這個主題提供靈感和有趣的討論！

免責聲明?：此實現僅適用于實驗，可能無法達到所需的安全性。?特別是，TensorFlow目前似乎并沒有考慮到這個應用程序的設計，雖然現在看起來并非如此，但是例如在未來的版本中，可能會在該場景后面執行優化來打破預期的安全屬性。?下面更多注釋?。

動機

正如上文所暗示的那樣，實施安全計算協議（如SPDZ?）由于其分布式性質是一項不平凡的任務，只有在我們開始引入各種優化（?但?可以?完成?）時才會變得更糟。?例如，必須考慮如何最好地協調多個程序的同時執行，如何最小化跨網絡發送數據的開銷，以及如何有效地將其與計算交錯，以便一臺服務器很少在另一臺服務器上等待。最重要的是，我們可能還想支持不同的硬件平臺，包括CPU和GPU等，并且對于任何認真的工作來說，使用可視化檢查，調試和分析工具來識別問題和瓶頸是非常有價值的。

此外，還應該很容易地嘗試各種優化，例如改進計算以提高性能，?重新使用中間結果和屏蔽值?，以及在執行期間以三元組形式提供新鮮的“原材料”，而不是僅生成大批量提前在離線階段。?獲得所有這一切都是正確的，這是以前的博客文章集中在安全計算協議背后的原理并簡單地在本地完成的一個原因。

幸運的是，現代分布式計算框架，如TensorFlow?，由于其在大型數據集上的高級機器學習中的使用，?近來正在接受大量研究和工程關注。?由于我們的重點是私人機器學習，所以存在一個自然的大的基本重疊。?特別是，我們感興趣的安全操作是張量加法，減法，乘法，點積，截斷和采樣，它們在TensorFlow中都具有不安全但高度優化的對應物。

先決條件

我們假設TensorFlow和SPDZ協議背后的主要原理已經被理解了 - 如果不是這樣的話，前者（包括白皮書?）和后者的前期?博客?文章都有很多?優秀的?資源?。?至于涉及到的不同方面，我們在這里也假定有兩個服務器，一個加密生產者，一個輸入提供者和一個輸出接收者。

但是一個重要的注意事項是TensorFlow的工作原理是首先構造一個隨后在會話中執行的靜態計算圖?。?例如，檢查我們從TensorBoard中的sigmoid(dot(w, x) + b)得到的圖表顯示如下。

這意味著我們在這篇文章中的努力關注于構建這樣一個圖表，而不是像之前的實際執行：我們在某種程度上制作了一個小型編譯器，將用簡單語言表達的安全計算轉換為TensorFlow程序。?因此，我們不僅可以從更高層次的抽象中受益，而且可以從TensorFlow中已經進入優化圖形執行的大量工作中受益。

查看完整代碼示例的實驗?。

基本

我們的需求與TensorFlow已經提供的操作很好地吻合，如下所示，除了一個主要的例外：當在安全設置中處理固定點數字時，為了匹配浮點數的典型精度，我們最終編碼并操作整數大于32或64位的典型字長，但今天這些是TensorFlow提供操作的唯一尺寸（與當前GPU支持有關的限制）。

幸運的是，對于我們需要的操作，有效的方法可以讓我們模擬使用一組具有相同形狀但是例如32位整數的張量列表對?120位整數的張量進行算術運算。?此外，這種分解還具有我們可以獨立地對列表中的每個張量進行操作的好特性，因此除了啟用TensorFlow之外，這還允許大多數操作并行執行，并且實際上可以提高效率盡管它聽起來可能聽起來更加昂貴，但它的數量更大。

我們在其他地方討論這個細節?，并在本文的其余部分簡單地假定在張量列表上執行預期操作的操作crt_add?，?crt_sub?，?crt_mul?，?crt_dot?，?crt_mod和sample。?請注意，?crt_mod?，?crt_mul和crt_sub一起允許我們為定點截斷定義右移操作。

私人張量

每個私人張量由兩臺服務器決定。?由于上面提到的原因，每個份額都由張量列表給出，這些張量由圖中的節點列表表示。?為了隱藏這種復雜性，我們引入一個簡單的類如下。

class PrivateTensor : def __init__ ( self , share0 , share1 ): self . share0 = share0 self . share1 = share1 @property def shape ( self ): return self . share0 [ 0 ] . shape @property def unwrapped ( self ): return self . share0 , self . share1

并且感謝TensorFlow，我們可以在圖形創建時知道張量的形狀，這意味著我們不必自己跟蹤這些。

簡單的操作

由于安全操作通常會用幾個TensorFlow操作來表示，因此我們使用抽象操作（如add，?mul和dot作為構造計算圖的便捷方式。?第一個是add?，其中結果圖簡單地指示兩臺服務器在本地合并它們各自使用由crt_add構建的子圖的crt_add?。

def add ( x , y ): assert isinstance ( x , PrivateTensor ) assert isinstance ( y , PrivateTensor ) x0 , x1 = x . unwrapped y0 , y1 = y . unwrapped with tf . name_scope ( 'add' ): with tf . device ( SERVER_0 ): z0 = crt_add ( x0 , y0 ) with tf . device ( SERVER_1 ): z1 = crt_add ( x1 , y1 ) z = PrivateTensor ( z0 , z1 ) return z

注意使用tf.device()來表示哪個服務器正在做什么很容易！?該命令將計算及其結果值綁定到指定主機，并指示TensorFlow自動插入適當的網絡操作，以確保輸入值在需要時可用！

例如，在上面的例子中，如果x0先前是輸入提供者，那么TensorFlow將插入發送和接收指令，將SERVER_0作為計算add一部分復制到SERVER_0?。?所有這些都被抽象出來，框架將嘗試找出最佳策略，以便準確優化何時執行發送和接收，包括批量更好地利用網絡并保持計算單元繁忙。

另一方面，?tf.name_scope()命令僅僅是一個邏輯抽象，它不會影響計算，但可用于通過將子圖組合為單個組件來使圖更容易在TensorBoard中可視化，如前所述。

請注意，如上所述，選擇TensorBoard中的Device?coloring，我們也可以使用它來驗證操作實際計算的位置，在這種情況下，添加確實是由兩臺服務器在本地完成的（綠色和綠松石）。

點產品

接下來我們轉向點產品。?這是比較復雜的，至少因為我們現在需要涉及加密生產者，還因為兩個服務器必須相互通信作為計算的一部分。

def dot ( x , y ): assert isinstance ( x , PrivateTensor ) assert isinstance ( y , PrivateTensor ) x0 , x1 = x . unwrapped y0 , y1 = y . unwrapped with tf . name_scope ( 'dot' ): # triple generation with tf . device ( CRYPTO_PRODUCER ): a = sample ( x . shape ) b = sample ( y . shape ) ab = crt_dot ( a , b ) a0 , a1 = share ( a ) b0 , b1 = share ( b ) ab0 , ab1 = share ( ab ) # masking after distributing the triple with tf . device ( SERVER_0 ): alpha0 = crt_sub ( x0 , a0 ) beta0 = crt_sub ( y0 , b0 ) with tf . device ( SERVER_1 ): alpha1 = crt_sub ( x1 , a1 ) beta1 = crt_sub ( y1 , b1 ) # recombination after exchanging alphas and betas with tf . device ( SERVER_0 ): alpha = reconstruct ( alpha0 , alpha1 ) beta = reconstruct ( beta0 , beta1 ) z0 = crt_add ( ab0 , crt_add ( crt_dot ( a0 , beta ), crt_add ( crt_dot ( alpha , b0 ), crt_dot ( alpha , beta )))) with tf . device ( SERVER_1 ): alpha = reconstruct ( alpha0 , alpha1 ) beta = reconstruct ( beta0 , beta1 ) z1 = crt_add ( ab1 , crt_add ( crt_dot ( a1 , beta ), crt_dot ( alpha , b1 ))) z = PrivateTensor ( z0 , z1 ) z = truncate ( z ) return z

但是，通過tf.device()我們發現這仍然是相對直接的，至少如果安全點產品的協議已經被理解了。?我們首先構造一個圖形，使加密生成器生成一個新的點三元組。?該圖的輸出節點是a0, a1, b0, b1, ab0, ab1

隨著crt_sub我們然后分別為使用a和b屏蔽x和y的兩臺服務器構建圖。?TensorFlow將再次SERVER_0在執行期間插入將例如a0的值發送到SERVER_0網絡代碼。

在第三步中，我們在每臺服務器上重建alpha和beta?，并計算重組步驟以獲得點積。?請注意，我們必須為每個服務器定義alpha和beta兩次，因為雖然它們包含相同的值，但如果我們只在一臺服務器上定義它們，但在兩臺服務器上都使用它們，那么我們會隱式插入其他網絡操作，因此減慢了計算速度。

回到TensorBoard，我們可以驗證節點確實與正確的玩家綁定在一起，黃色是加密制作者，綠色和綠松石是兩個服務器。?注意這里有tf.name_scope()的方便。

組態

為了充分聲明這使得安全計算的分布式方面更容易表達，我們還必須看到td.device()實際上需要什么才能按預期工作。?在下面的代碼中，我們首先定義一個任意的作業名稱，后面跟著我們五個玩家的標識符?更有意思的是，我們只需指定他們的網絡主機并將其包裝在ClusterSpec?。?而已！

JOB_NAME = 'spdz' SERVER_0 = '/job:{}/task:0' . format ( JOB_NAME ) SERVER_1 = '/job:{}/task:1' . format ( JOB_NAME ) CRYPTO_PRODUCER = '/job:{}/task:2' . format ( JOB_NAME ) INPUT_PROVIDER = '/job:{}/task:3' . format ( JOB_NAME ) OUTPUT_RECEIVER = '/job:{}/task:4' . format ( JOB_NAME ) HOSTS = [ '10.132.0.4:4440' , '10.132.0.5:4441' , '10.132.0.6:4442' , '10.132.0.7:4443' , '10.132.0.8:4444' , ] CLUSTER = tf . train . ClusterSpec ({ JOB_NAME : HOSTS })

請注意，在截圖中，我們實際上是在同一主機上運行輸入提供者和輸出接收者，因此都顯示為3/device:CPU:0?。

最后，每個玩家執行的代碼都是如此簡單。

server = tf . train . Server ( CLUSTER , job_name = JOB_NAME , task_index = ROLE ) server . start () server . join ()

這里ROLE的值是五個玩家運行的程序之間唯一不同的東西，通常作為命令行參數給出。

改進

隨著基礎知識的到位，我們可以看一些優化。

跟蹤節點

我們的第一個改進允許我們重復使用計算。?例如，如果我們需要兩次dot(x, y)的結果，那么我們希望避免第二次計算它，而是重新使用第一次。?具體而言，我們希望跟蹤圖中的節點并盡可能地鏈接到它們。

為此，我們只需在構建圖時維護一個全局的PrivateTensor引用字典，并在添加新節點之前使用它查找已經存在的結果。?例如，?dot現在變成如下。

def dot ( x , y ): assert isinstance ( x , PrivateTensor ) assert isinstance ( y , PrivateTensor ) node_key = ( 'dot' , x , y ) z = nodes . get ( node_key , None ) if z is None : # ... as before ... z = PrivateTensor ( z0 , z1 ) z = truncate ( z ) nodes [ node_key ] = z return z

雖然對于某些應用來說已經很重要，但是這一改變也為我們的下一個改進打開了。

重新使用蒙版張量

我們已經?提到過?，我們最好想要掩蓋每個私人張量最多一次，主要是為了節省網絡。?例如，如果我們計算dot(w, x)和dot(w, y)那么我們希望在兩者中都使用相同的w掩碼版本。?具體而言，如果我們使用相同的掩蔽張量進行多項操作，那么掩蓋它的成本可以分攤。

但是就目前的設置而言，我們每次計算時都會掩蓋，例如dot或多dot?，因為掩模會被燒入這些點。?所以為了避免這種情況，我們只是簡單地做一個明確的操作，另外還允許我們在不同的操作中使用相同的屏蔽版本。

def mask ( x ): assert isinstance ( x , PrivateTensor ) node_key = ( 'mask' , x ) masked = nodes . get ( node_key , None ) if masked is None : x0 , x1 = x . unwrapped shape = x . shape with tf . name_scope ( 'mask' ): with tf . device ( CRYPTO_PRODUCER ): a = sample ( shape ) a0 , a1 = share ( a ) with tf . device ( SERVER_0 ): alpha0 = crt_sub ( x0 , a0 ) with tf . device ( SERVER_1 ): alpha1 = crt_sub ( x1 , a1 ) # exchange of alphas with tf . device ( SERVER_0 ): alpha_on_0 = reconstruct ( alpha0 , alpha1 ) with tf . device ( SERVER_1 ): alpha_on_1 = reconstruct ( alpha0 , alpha1 ) masked = MaskedPrivateTensor ( a , a0 , a1 , alpha_on_0 , alpha_on_1 ) nodes [ node_key ] = masked return masked

請注意，我們引入了一個MaskedPrivateTensor類作為其中的一部分，這也是對從mask(x)得到的五個張量列表進行抽象的簡便方法。

class MaskedPrivateTensor ( object ): def __init__ ( self , a , a0 , a1 , alpha_on_0 , alpha_on_1 ): self . a = a self . a0 = a0 self . a1 = a1 self . alpha_on_0 = alpha_on_0 self . alpha_on_1 = alpha_on_1 @property def shape ( self ): return self . a [ 0 ] . shape @property def unwrapped ( self ): return self . a , self . a0 , self . a1 , self . alpha_on_0 , self . alpha_on_1

有了這個，我們可以像下面這樣重寫dot?，它現在只負責重組步驟。

def dot ( x , y ): assert isinstance ( x , PrivateTensor ) or isinstance ( x , MaskedPrivateTensor ) assert isinstance ( y , PrivateTensor ) or isinstance ( y , MaskedPrivateTensor ) node_key = ( 'dot' , x , y ) z = nodes . get ( node_key , None ) if z is None : if isinstance ( x , PrivateTensor ): x = mask ( x ) if isinstance ( y , PrivateTensor ): y = mask ( y ) a , a0 , a1 , alpha_on_0 , alpha_on_1 = x . unwrapped b , b0 , b1 , beta_on_0 , beta_on_1 = y . unwrapped with tf . name_scope ( 'dot' ): with tf . device ( CRYPTO_PRODUCER ): ab = crt_dot ( a , b ) ab0 , ab1 = share ( ab ) with tf . device ( SERVER_0 ): alpha = alpha_on_0 beta = beta_on_0 z0 = crt_add ( ab0 , crt_add ( crt_dot ( a0 , beta ), crt_add ( crt_dot ( alpha , b0 ), crt_dot ( alpha , beta )))) with tf . device ( SERVER_1 ): alpha = alpha_on_1 beta = beta_on_1 z1 = crt_add ( ab1 , crt_add ( crt_dot ( a1 , beta ), crt_dot ( alpha , b1 ))) z = PrivateTensor ( z0 , z1 ) z = truncate ( z ) nodes [ node_key ] = z return z

作為驗證，我們可以看到TensorBoard向我們展示了預期的圖結構，在這種情況下，在sigmoid圖中。

這里square(x)值首先被計算出來，然后被屏蔽，最后被重復使用四次。

雖然效率低下，但TensorFlow的數據流性質一般只會重新計算圖表中在兩次執行之間發生變化的部分，但這不適用于涉及通過例如tf.random_uniform進行采樣的操作，該操作用于我們的分享和掩飾。?因此，掩碼不會在執行過程中重復使用。

緩存值

為了解決上述問題，我們可以引入在圖的不同執行過程中存活的值的緩存，并且一個簡單的方法是將張量存儲在變量中?。?正常執行將從這些讀取，而明確的cache_populators操作集允許我們填充它們。

例如，用這種cache操作包裝我們的兩張張量w和b可以得到下面的圖。

執行緩存填充操作時，TensorFlow會自動計算出需要執行的圖的哪些子部分以生成要緩存的值，哪些可以忽略。

同樣，在預測時，在這種情況下跳過共享和屏蔽。

緩沖三元組

回想一下，?三元組的主要目的是將加密生產者的計算轉移到離線階段，并提前將其結果分發給兩個服務器，以便稍后在在線階段加快計算速度。

到目前為止，我們還沒有做過任何事情來指定這會發生，但通過閱讀上述代碼，假設加密生產者將與兩臺服務器同步計算，在其計算過程中注入空閑等待時間并非不合理。?然而，從實驗看來，TensorFlow似乎已經足夠聰明，可以優化圖形來做正確的事情和批量三重分配，這大概是為了節省網絡。?盡管我們仍然有一個初始等待期，但我們可以通過引入一個單獨的計算和分配執行來填補緩沖區，從而擺脫困境。

我們現在將跳過這個問題，而是在看私人培訓時回到它，因為通過提前分發培訓數據來期待顯著的性能改進并不是不合理的。

剖析

作為在TensorFlow中構建數據流程序感到興奮的最后一個理由，我們還會查看內置的運行時統計信息?。?我們已經在上面看到了內置的詳細跟蹤支持，但在TensorBoard中我們也可以很容易地看到每個操作在計算和內存方面的成本。?這里報告的數字來自下面的實驗?。

上面的熱圖表明，?sigmoid是運行中最昂貴的操作，dot產品需要大約30ms才能執行。?此外，在下圖中，我們已經進一步導航到點塊，并看到在這個特定運行中共享大約3ms。

通過這種方式，我們可以識別瓶頸并比較不同方法的性能。?如果需要，我們當然可以切換到追蹤更多細節。

實驗

GitHub存儲庫包含實驗所需的代碼，包括用于設置主機的本地配置或GCP配置的示例和說明。?對于使用邏輯回歸模型的私人預測的運行示例，我們使用GCP配置，即各方在位于同一Google Cloud區域的不同虛擬主機上運行，??這里是一些較弱的實例，即雙核和10 GB內存。

我們的程序的一個稍微簡化的版本如下，我們首先公開訓練一個模型，為私人預測計算建立一個圖形，然后在新的會話中運行它。?該模型有點隨意挑選有100個功能。

from config import session from tensorspdz import ( define_input , define_variable , add , dot , sigmoid , cache , mask , encode_input , decode_output ) # publicly train `weights` and `bias` weights , bias = train_publicly () # define shape of unknown input shape_x = X . shape # construct graph for private prediction input_x , x = define_input ( shape_x , name = 'x' ) init_w , w = define_variable ( weights , name = 'w' ) init_b , b = define_variable ( bias , name = 'b' ) if use_caching : w = cache ( mask ( w )) b = cache ( b ) y = sigmoid ( add ( dot ( x , w ), b )) # start session between all players with session () as sess : # share and distribute `weights` and `bias` to the two servers sess . run ([ init_w , init_b ]) if use_caching : # compute and store cached values sess . run ( cache_populators ) # prepare to use `X` as private input for prediction feed_dict = encode_input ([ ( input_x , X ) ]) # run secure computation and reveal output y_pred = sess . run ( reveal ( y ), feed_dict = feed_dict ) print decode_output ( y_pred )

以不同的X大小運行這幾次會給出下面的計時，整個計算被考慮在內，包括三次生成和分配;?有點令人驚訝的是，高速緩存屏蔽值之間沒有真正的區別。

處理大小為1,10和100的批處理時間大致相同，平均約為60ms，這可能意味著由于網絡而導致的更低延遲限制。?在1000時間跳到?110ms，在10000到600ms之間，最后在100,000到5s之間。?因此，如果延遲比我們可以每秒執行?1600次預測更重要，而如果更靈活，那么至少每秒至少20,000次。

然而，這只是測量分析報告的時間，實際執行時間會稍長一些;?希望TensorFlow?tf.serving一些面向生產的工具（如tf.serving可以改進這一點。

思考

在私人預測之后，看私人訓練當然也會很有趣。?緩存蒙面訓練數據在這里可能更加相關，因為它在整個過程中保持固定。

模型的服務也可以改進，例如使用生產就緒的tf.serving?，可以避免很多當前的編排開銷，以及具有可以安全地向公眾公開的端點。

最后，在五方之間的溝通等方面還有安全方面的改進。?特別是，在當前版本的TensorFlow中，所有通信都是通過未加密和未經身份驗證的gRPC連接進行的，這意味著原則上監聽網絡流量的人可以了解所有私有值。?由于對gRPC的支持已經存在，所以在TensorFlow中使用它可能會很簡單，而且不會對性能產生重大影響。?同樣，TensorFlow目前不會為tf.random_uniform使用強大的偽隨機生成器，因此共享和屏蔽并不像它們可能的那樣安全;?增加一個密碼強的隨機性操作可能是直截了當的，應該給出大致相同的性能。

https://mortendahl.github.io/2018/03/01/secure-computation-as-dataflow-programs/

與50位技術專家面對面20年技術見證，附贈技術全景圖

總結

以上是生活随笔為你收集整理的【译】Secure Computations as Dataflow Programs Implementing the SPDZ Protocol using TensorFlow的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。