使用多處理模塊運行並行進程，其中一個進程由另一個進程供（依賴）維特比算法

Question

我最近使用了Python的多處理模塊，以加快Hidden Markov模型的前向后退算法，因為前向過濾和后向過濾可以獨立運行。 看到一半的運行時間是令人敬畏的。

我現在嘗試在我的迭代維特比算法中包含一些多處理程序。在該算法中，我嘗試運行的兩個進程不是獨立的。 val_max部分可以獨立運行，但arg_max [t]取決於val_max [t-1]。 因此，我想到了可以將val_max作為單獨的進程運行，然后將arg_max也作為可以由val_max提供的單獨進程運行的想法。

我承認我在這里有點兒不了解，對多處理的了解不多，除了觀看一些基本視頻並瀏覽博客外。 我在下面提供了我的嘗試，但是沒有用。

import numpy as np
from time import time,sleep
import multiprocessing as mp

class Viterbi:


    def __init__(self,A,B,pi):
        self.M = A.shape[0] # number of hidden states
        self.A = A  # Transition Matrix
        self.B = B   # Observation Matrix
        self.pi = pi   # Initial distribution
        self.T = None   # time horizon
        self.val_max = None
        self.arg_max = None
        self.obs = None
        self.sleep_time = 1e-6
        self.output = mp.Queue()


    def get_path(self,x):
        # returns the most likely state sequence given observed sequence x
        # using the Viterbi algorithm
        self.T = len(x)
        self.val_max = np.zeros((self.T, self.M))
        self.arg_max = np.zeros((self.T, self.M))
        self.val_max[0] = self.pi*self.B[:,x[0]]
        for t in range(1, self.T):
            # Indepedent Process
            self.val_max[t] = np.max( self.A*np.outer(self.val_max[t-1],self.B[:,obs[t]]) , axis = 0  ) 
            # Dependent Process
            self.arg_max[t] = np.argmax( self.val_max[t-1]*self.A.T, axis = 1)

        # BACKTRACK
        states = np.zeros(self.T, dtype=np.int32)
        states[self.T-1] = np.argmax(self.val_max[self.T-1])
        for t in range(self.T-2, -1, -1):
            states[t] = self.arg_max[t+1, states[t+1]]
        return states

    def get_val(self):
        '''Independent Process'''
        for t in range(1,self.T):
            self.val_max[t] = np.max( self.A*np.outer(self.val_max[t-1],self.B[:,self.obs[t]]) , axis = 0  ) 
        self.output.put(self.val_max)

    def get_arg(self):
        '''Dependent Process'''
        for t in range(1,self.T):
            while 1:
                # Process info if available
                if self.val_max[t-1].any() != 0:
                    self.arg_max[t] = np.argmax( self.val_max[t-1]*self.A.T, axis = 1)
                    break
                # Else sleep and wait for info to arrive
                sleep(self.sleep_time)
        self.output.put(self.arg_max)

    def get_path_parallel(self,x):
        self.obs = x
        self.T = len(obs)
        self.val_max = np.zeros((self.T, self.M))
        self.arg_max = np.zeros((self.T, self.M))
        val_process = mp.Process(target=self.get_val)
        arg_process = mp.Process(target=self.get_arg)  
        # get first initial value for val_max which can feed arg_process
        self.val_max[0] = self.pi*self.B[:,obs[0]]
        arg_process.start()
        val_process.start()
        arg_process.join()
        val_process.join()

注意：get_path_parallel還沒有回溯。

似乎val_process和arg_process從未真正運行過。 真的不確定為什么會這樣。 您可以在Wikipedia示例上運行viterbi算法的代碼。

obs = np.array([0,1,2])  # normal then cold and finally dizzy  

pi = np.array([0.6,0.4])

A = np.array([[0.7,0.3],
             [0.4,0.6]])

B = np.array([[0.5,0.4,0.1],
             [0.1,0.3,0.6]]) 

viterbi = Viterbi(A,B,pi)
path = viterbi.get_path(obs)

我也嘗試使用Ray。 但是，我不知道自己在那兒實際上在做什么。 您能否幫我推薦我該怎么做才能使並行版本運行。 我一定做錯了什么，但我不知道怎么做。

您的幫助將不勝感激。

Answer 1

感謝@SıddıkAçıl，我設法使我的代碼正常工作。 生產者-消費者模式是解決問題的關鍵。 我還意識到，這些過程可以成功運行，但是如果沒有將最終結果存儲在某種“結果隊列”中，則該過程將消失。 我的意思是，我通過允許進程start（）在numpy數組val_max和arg_max中填充值，但是當我調用它們時，它們仍然是np.zero數組。 我驗證了它們確實可以通過打印它們來填充正確的數組，就像進程將要終止時一樣（最后是self.T在迭代中）。 因此，我沒有打印它們，而是在最后一次迭代中將它們添加到多處理Queue對象中，以捕獲整個填充數組。

我在下面提供了更新的工作代碼。 注意：它正在工作，但完成所需的時間是串行版本的兩倍。 我對為什么會這樣的想法如下：

1. 我可以讓它作為兩個進程運行，但實際上不知道如何正確執行。 有經驗的程序員可能知道如何使用chunksize參數對其進行修復。
2. 我分離的兩個過程是numpy矩陣運算。 這些過程執行得如此之快，以至於並發（多處理）的開銷不值得進行理論上的改進。 如果這兩個過程是兩個原始的for循環（在Wikipedia和大多數實現中使用的），那么多處理可能會有所收獲（也許我應該對此進行研究）。 此外，由於我們具有生產者-消費者模式，而不是兩個獨立的過程（生產者-生產者模式），因此我們只能期望生產者-消費者模式的運行時間與兩個過程中最長的一樣長（在這種情況下，生產者將花費兩倍的時間）。只要消費者）。 我們不能期望運行時間像生產者-生產者方案那樣減少一半（這是在我的並行前向后HMM過濾算法中發生的）。
3. 我的計算機有4個核心，並且numpy已經對其操作進行了內置CPU多處理優化。 通過我嘗試使用內核來使代碼更快，我剝奪了numpy可以更有效使用的內核。 為了弄清楚這一點，我將對numpy操作進行計時，以查看它們在並發版本中是否比串行版本慢。

如果我學到新東西，我會更新。 如果您可能知道導致我的並發代碼這么慢的真正原因，請告訴我。 這是代碼：

import numpy as np
from time import time
import multiprocessing as mp

class Viterbi:


    def __init__(self,A,B,pi):
        self.M = A.shape[0] # number of hidden states
        self.A = A  # Transition Matrix
        self.B = B   # Observation Matrix
        self.pi = pi   # Initial distribution
        self.T = None   # time horizon
        self.val_max = None
        self.arg_max = None
        self.obs = None
        self.intermediate = mp.Queue()
        self.result = mp.Queue()



    def get_path(self,x):
        '''Sequential/Serial Viterbi Algorithm with backtracking'''
        self.T = len(x)
        self.val_max = np.zeros((self.T, self.M))
        self.arg_max = np.zeros((self.T, self.M))
        self.val_max[0] = self.pi*self.B[:,x[0]]
        for t in range(1, self.T):
            # Indepedent Process
            self.val_max[t] = np.max( self.A*np.outer(self.val_max[t-1],self.B[:,obs[t]]) , axis = 0  ) 
            # Dependent Process
            self.arg_max[t] = np.argmax( self.val_max[t-1]*self.A.T, axis = 1)

        # BACKTRACK
        states = np.zeros(self.T, dtype=np.int32)
        states[self.T-1] = np.argmax(self.val_max[self.T-1])
        for t in range(self.T-2, -1, -1):
            states[t] = self.arg_max[t+1, states[t+1]]
        return states

    def get_val(self,intial_val_max):
        '''Independent Poducer Process'''
        val_max = intial_val_max
        for t in range(1,self.T):
            val_max = np.max( self.A*np.outer(val_max,self.B[:,self.obs[t]]) , axis = 0  )
            #print('Transfer: ',self.val_max[t])
            self.intermediate.put(val_max)
            if t == self.T-1:
                self.result.put(val_max)   # we only need the last val_max value for backtracking




    def get_arg(self):
        '''Dependent Consumer Process.'''
        t = 1
        while t < self.T:
            val_max =self.intermediate.get()
            #print('Receive: ',val_max)
            self.arg_max[t] = np.argmax( val_max*self.A.T, axis = 1)
            if t == self.T-1:
                self.result.put(self.arg_max)
            #print('Processed: ',self.arg_max[t])
            t += 1

    def get_path_parallel(self,x):
        '''Multiprocessing producer-consumer implementation of Viterbi algorithm.'''
        self.obs = x
        self.T = len(obs)
        self.arg_max = np.zeros((self.T, self.M))  # we don't tabulate val_max anymore
        initial_val_max = self.pi*self.B[:,obs[0]]
        producer_process = mp.Process(target=self.get_val,args=(initial_val_max,),daemon=True)
        consumer_process = mp.Process(target=self.get_arg,daemon=True) 
        self.intermediate.put(initial_val_max)  # initial production put into pipeline for consumption
        consumer_process.start()  # we can already consume initial_val_max
        producer_process.start()
        #val_process.join()
        #arg_process.join()
        #self.output.join()
        return self.backtrack(self.result.get(),self.result.get()) # backtrack takes last row of val_max and entire arg_max

    def backtrack(self,val_max_last_row,arg_max):
        '''Backtracking the Dynamic Programming solution (actually a Trellis diagram)
           produced by Multiprocessing Viterbi algorithm.'''
        states = np.zeros(self.T, dtype=np.int32)
        states[self.T-1] = np.argmax(val_max_last_row)
        for t in range(self.T-2, -1, -1):
            states[t] = arg_max[t+1, states[t+1]]
        return states



if __name__ == '__main__':

    obs = np.array([0,1,2])  # normal then cold and finally dizzy  

    T = 100000
    obs = np.random.binomial(2,0.3,T)        

    pi = np.array([0.6,0.4])

    A = np.array([[0.7,0.3],
                 [0.4,0.6]])

    B = np.array([[0.5,0.4,0.1],
                 [0.1,0.3,0.6]]) 

    t1 = time()
    viterbi = Viterbi(A,B,pi)
    path = viterbi.get_path(obs)
    t2 = time()
    print('Iterative Viterbi')
    print('Path: ',path)
    print('Run-time: ',round(t2-t1,6)) 
    t1 = time()
    viterbi = Viterbi(A,B,pi)
    path = viterbi.get_path_parallel(obs)
    t2 = time()
    print('\nParallel Viterbi')
    print('Path: ',path)
    print('Run-time: ',round(t2-t1,6))

Answer 2

歡迎來到SO。 考慮看一下在多處理中大量使用的生產者-消費者模式。

請注意，Python中的多處理會為您在Windows上創建的每個進程重新實例化代碼。 因此，您的Viterbi對象及其隊列字段不同。

通過以下方式觀察此行為：

import os

def get_arg(self):
    '''Dependent Process'''
    print("Dependent ", self)
    print("Dependent ", self.output)
    print("Dependent ", os.getpid())

def get_val(self):
    '''Independent Process'''
    print("Independent ", self)
    print("Independent ", self.output)
    print("Independent ", os.getpid())

if __name__ == "__main__":
    print("Hello from main process", os.getpid())
    obs = np.array([0,1,2])  # normal then cold and finally dizzy  

    pi = np.array([0.6,0.4])

    A = np.array([[0.7,0.3],
             [0.4,0.6]])

    B = np.array([[0.5,0.4,0.1],
             [0.1,0.3,0.6]]) 

    viterbi = Viterbi(A,B,pi)
    print("Main viterbi object", viterbi)
    print("Main viterbi object queue", viterbi.output)
    path = viterbi.get_path_parallel(obs)

由於存在三個不同的過程，因此存在三個不同的Viterbi對象。 因此，就並行性而言，您需要的不是流程。 您應該探索Python提供的threading庫。