c - 反向传播算法的多线程

Question

为了加速一些神经网络学习，我尝试了一些多线程，因为对于特定层，每个神经元的计算都是相互独立的。

我使用的原始函数是一些基本的反向传播算法，用于评估网络中的增量:

δ = 导数 * Σ(权重 * 前面的 δ)

void backpropagation (Autoencoder* AE)
{
   int i, j, k;
   for(i = AE->numLayer-2; i >= 0; i--)
   {
      for(j = 0; j < AE->layer[i].size; j++)
      {
         register double sum = 0.0;
         for(k = 0; k < AE->layer[i+1].size; k++)
         {
            sum += AE->layer[i+1].neuron[k].weight[j] * AE->layer[i+1].neuron[k].delta;
         }
         AE->layer[i].neuron[j].delta = AE->layer[i].neuron[j].derivative * sum;
      }
   }
}

自动编码器是包含神经网络的结构。它工作得很好，如果有点慢，首先尝试这个功能似乎是个好主意。

修改后的函数如下:

void backpropagationmultithread (Autoencoder* AE, unsigned int ncore, pthread_t* pth)
{
   int i, j;
   unsigned int neuronpercore, extra;
   sem_t semaphore;
   argThread* args[ncore];
   for(i = AE->numLayer-2; i >= 0; i--)
   {
      neuronpercore = AE->layer[i].size / ncore;
      extra = neuronpercore + (AE->layer[i].size % ncore);
      sem_init(&semaphore, 0, -ncore);
      for(j = 0; j < ncore; j++)
      {
         args[j] = malloc(sizeof(argThread));
         args[j]->layer = i;
         args[j]->AE = AE;
         args[j]->sem = &semaphore;
         args[j]->startat = neuronpercore * j;
         args[j]->nneurons = (j!=ncore-1)?neuronpercore:extra;
         pthread_create(&pth[j], NULL, backpropagationthread, (void*)args[j]);
      }
      sem_wait(&semaphore);
      for(j = 0; j < ncore; j++)
      {
         pthread_cancel(pth[j]);
      }
   }
}

以及新线程的功能:

void* backpropagationthread (void* arg)
{
   argThread* args = (argThread*) arg;
   unsigned int j,k,layer = args->layer, start = args->startat, end = args->startat + args->nneurons;
   Autoencoder* AE = args->AE;
   for(j = start; j < end; j++)
   {
      register double sum = 0.0;
      for(k = 0; k < AE->layer[layer+1].size; k++)
      {
         sum += AE->layer[layer+1].neuron[k].weight[j] * AE->layer[layer+1].neuron[k].delta;
      }
      AE->layer[layer].neuron[j].delta = AE->layer[layer].neuron[j].derivative * sum;
   }
   sem_post(args->sem);
   free(arg);
   return NULL;
}

argThread 只是一个小结构，包含要传递给线程的所有参数，ncore 是 CPU 内核的数量。这个想法是将每一层分成大致相等数量的神经元，由每个线程单独处理(如果它们不是倍数，则最后一个包含所有额外的神经元)。

新函数在某种程度上确实有效，而且速度更快，但在达到一定阈值后不再收敛，旧函数收敛的地方，我找不到为什么它的行为会改变。我是否遗漏了一些神经元或权重？

Answer 1

我前段时间为Encog实现了一个多线程反向传播算法。我用 Java 编写了这个，但是当我用 C 实现它时，我使用了 OpenMP，而不是 pthreads。您可以在此处查看我的 C 实现。

https://github.com/encog/encog-c

我还写了一篇关于我在多线程中执行反向传播的方法的文章。你可以在这里看到我的文章。

http://www.heatonresearch.com/encog/mprop/compare.html

在 Stack Overflow 上也有一些关于此的其他问题。大多数似乎都引用了我的算法。

Multithreaded backpropagation How can I apply multithreading to the backpropagation neural network training?