0

我正在处理某种庞大的数据集，我需要使用内核化感知器进行二进制分类。我正在使用这个源代码：https ://gist.github.com/mblondel/656147 。

这里有 3 件事可以并行化，1）内核计算，2）更新规则 3）投影部分。我还做了一些其他的加速，比如计算内核的上三角部分，然后使其成为完全对称矩阵：

 K = np.zeros((n_samples, n_samples))
        for index in itertools.combinations_with_replacement(range(n_samples),2):
            K[index] = self.kernel(X[ index[0] ],X[ index[1] ],self.gamma)      
        #make the full KERNEL
        K = K + np.triu(K,1).T

我还将投影部分并行化，例如：

   def parallel_project(self,X):
        """ Function to parallelizing prediction"""    
        y_predict=np.zeros(self.nOfWorkers,"object")

        pool=mp.Pool(processes=self.nOfWorkers)
        results=[pool.apply_async(prediction_worker,args=(self.alpha,self.sv_y,self.sv,self.kernel,(parts,))) for parts in np.array_split(X,self.nOfWorkers)]
        pool.close()
        pool.join()
        i=0

        for r in results:
            y_predict[i]=r.get()
            i+=1
        return np.hstack(y_predict)

和工人：

def prediction_worker(alpha,sv_y,sv,kernel,samples):
    """ WORKER FOR PARALELIZING PREDICTION PART"""
    print "starting:" , mp.current_process().name
    X= samples[0]
    y_predict=np.zeros(len(X))
    for i in range(len(X)):
        s = 0
        for a1, sv_y1, sv1 in zip(alpha, sv_y, sv):
            s += a1 * sv_y1 * kernel(X[i], sv1)
        y_predict[i]=s  
    return y_predict.flatten()

但代码仍然太慢。那么你能给我任何关于并行化或任何其他加速的提示吗？

备注：请证明通用解决方案，我不是在处理自定义内核功能。

谢谢

4

1 回答 1

1

这里有一些东西可以让你立即加速。Mathieu 示例代码中的内核采用单个样本，然后使用它们计算完整的 Gram 矩阵：

K = np.zeros((n_samples, n_samples))
for i in range(n_samples):
    for j in range(n_samples):
        K[i,j] = self.kernel(X[i], X[j])

这很慢，可以通过向量化内核函数来避免：

def linear_kernel(X, Y):
    return np.dot(X, Y.T)
def polynomial_kernel(X, Y, p=3):
    return (1 + np.dot(X, Y.T)) ** p
# the Gaussian RBF kernel is a bit trickier

现在 Gram 矩阵可以计算为

K = kernel(X, X)

应该相应地project更改功能以加快速度。

于 2013-07-18T10:08:57.743 回答