未定义对“设置（int，char**）和#x27；

我正在从事一个使用CUDA C训练多层神经网络的项目。问题是，当我尝试编译程序时，我得到了以下错误：

facetrain.o: In function `backprop_face':
facetrain.c:(.text+0x127): undefined reference to `bpnn_train_kernel'
backprop_kernel.o: In function `bpnn_train_kernel(BPNN*, float*, float*)':
tmpxft_0002fa78_00000000-4_backprop_kernel.cudafe1.cpp:(.text+0x6e6): undefined reference to `bpnn_layerforward(float*, float*, float**, int, int)'
tmpxft_0002fa78_00000000-4_backprop_kernel.cudafe1.cpp:(.text+0x703): undefined reference to `bpnn_output_error(float*, float*, float*, int, float*)'
tmpxft_0002fa78_00000000-4_backprop_kernel.cudafe1.cpp:(.text+0x72a): undefined reference to `bpnn_hidden_error(float*, int, float*, int, float**, float*, float*)'
tmpxft_0002fa78_00000000-4_backprop_kernel.cudafe1.cpp:(.text+0x745): undefined reference to `bpnn_adjust_weights(float*, int, float*, int, float**, float**)'
backprop_kernel.o: In function `main':
tmpxft_0002fa78_00000000-4_backprop_kernel.cudafe1.cpp:(.text+0x9a5): undefined reference to `setup(int, char**)'
collect2: ld returned 1 exit status
make: *** [backprop] Error 1

下面是background_kernel.cu的代码：

////////////////////////////////////////////////////////////////////////////////

extern void bpnn_layerforward(float *l1, float *l2, float **conn, int n1, int n2);

extern void bpnn_output_error(float *delta, float *target, float *output, int nj, float *err);

extern void bpnn_hidden_error(float *delta_h, int nh, float *delta_o, int no, float **who, float *hidden, float *err);

extern void bpnn_adjust_weights(float *delta, int ndelta, float *ly, int nly, float **w, float **oldw);


extern int setup(int argc, char** argv);

extern float **alloc_2d_dbl(int m, int n);

extern float squash(float x);

double gettime() {
  struct timeval t;
  gettimeofday(&t,NULL);
  return t.tv_sec+t.tv_usec*1e-6;
}

unsigned int num_threads = 0;
unsigned int num_blocks = 0;

////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main( int argc, char** argv) 
{
    setup(argc, argv);
}


void bpnn_train_kernel(BPNN *net, float *eo, float *eh)
{
  int in, hid, out;
  float out_err, hid_err;

  in = net->input_n;
  hid = net->hidden_n;
  out = net->output_n;   

#ifdef GPU  
  int m = 0;
  float *input_hidden_cuda;
  float *input_cuda;
  float *output_hidden_cuda;
  float *partial_sum;
  float *hidden_partial_sum;
  float *hidden_delta_cuda;
  float *input_prev_weights_cuda;
  float sum;
  float *input_weights_one_dim;
  float *input_weights_prev_one_dim;
  num_blocks = in / 16;  
  dim3  grid( 1 , num_blocks);
  dim3  threads(16 , 16);

  input_weights_one_dim = (float *) malloc((in + 1)* (hid + 1) * sizeof(float));
  input_weights_prev_one_dim = (float *) malloc((in + 1)* (hid + 1) * sizeof(float));
  partial_sum = (float *) malloc(num_blocks * WIDTH * sizeof(float));

  // this preprocessing stage is added to correct the bugs of wrong memcopy using two-dimensional net->inputweights
  for (int k = 0; k <= in; k++) {   
   for (int j = 0; j <= hid; j++) {
      input_weights_one_dim[m] = net->input_weights[k][j];
      input_weights_prev_one_dim[m] = net-> input_prev_weights[k][j];
      m++;
    }
  }

  cudaMalloc((void**) &input_cuda, (in + 1) * sizeof(float));
  cudaMalloc((void**) &output_hidden_cuda, (hid + 1) * sizeof(float));
  cudaMalloc((void**) &input_hidden_cuda, (in + 1) * (hid + 1) * sizeof(float));
  cudaMalloc((void**) &hidden_partial_sum, num_blocks * WIDTH * sizeof(float));


#endif

#ifdef CPU

  printf("Performing CPU computation\n");
  bpnn_layerforward(net->input_units, net->hidden_units,net->input_weights, in, hid);

#endif

#ifdef GPU

  printf("Performing GPU computation\n");

  //printf("in= %d, hid = %d, numblocks = %d\n", in, hid, num_blocks);

  cudaMemcpy(input_cuda, net->input_units, (in + 1) * sizeof(float), cudaMemcpyHostToDevice);
  cudaMemcpy(input_hidden_cuda, input_weights_one_dim, (in + 1) * (hid + 1) * sizeof(float), cudaMemcpyHostToDevice);



  bpnn_layerforward_CUDA<<< grid, threads >>>(input_cuda,
                                              output_hidden_cuda,
                                              input_hidden_cuda,
                                              hidden_partial_sum,
                                              in,
                                              hid);

  cudaThreadSynchronize();

  cudaError_t error = cudaGetLastError();
    if (error != cudaSuccess) {
        printf("bpnn kernel error: %s\n", cudaGetErrorString(error));
        exit(EXIT_FAILURE);
    }

  cudaMemcpy(partial_sum, hidden_partial_sum, num_blocks * WIDTH * sizeof(float), cudaMemcpyDeviceToHost);

  for (int j = 1; j <= hid; j++) {
    sum = 0.0;
    for (int k = 0; k < num_blocks; k++) {  
      sum += partial_sum[k * hid + j-1] ;
    }
    sum += net->input_weights[0][j];
    net-> hidden_units[j] = float(1.0 / (1.0 + exp(-sum)));
  }
  #endif

  bpnn_layerforward(net->hidden_units, net->output_units, net->hidden_weights, hid, out);
  bpnn_output_error(net->output_delta, net->target, net->output_units, out, &out_err);
  bpnn_hidden_error(net->hidden_delta, hid, net->output_delta, out, net->hidden_weights, net->hidden_units, &hid_err);  
  bpnn_adjust_weights(net->output_delta, out, net->hidden_units, hid, net->hidden_weights, net->hidden_prev_weights);

#ifdef CPU

  bpnn_adjust_weights(net->hidden_delta, hid, net->input_units, in, net->input_weights, net->input_prev_weights);

#endif  


#ifdef GPU

  cudaMalloc((void**) &hidden_delta_cuda, (hid + 1) * sizeof(float));
  cudaMalloc((void**) &input_prev_weights_cuda, (in + 1) * (hid + 1) * sizeof(float));

  cudaMemcpy(hidden_delta_cuda, net->hidden_delta, (hid + 1) * sizeof(float), cudaMemcpyHostToDevice);
  cudaMemcpy(input_prev_weights_cuda, input_weights_prev_one_dim, (in + 1) * (hid + 1) * sizeof(float), cudaMemcpyHostToDevice);
  cudaMemcpy(input_hidden_cuda, input_weights_one_dim, (in + 1) * (hid + 1) * sizeof(float), cudaMemcpyHostToDevice);


  bpnn_adjust_weights_cuda<<< grid, threads >>>(hidden_delta_cuda,  
                                                hid, 
                                                input_cuda, 
                                                in,
                                                input_hidden_cuda, 
                                                input_prev_weights_cuda
                                                );

  cudaMemcpy(net->input_units, input_cuda, (in + 1) * sizeof(float), cudaMemcpyDeviceToHost);
  cudaMemcpy(input_weights_one_dim, input_hidden_cuda, (in + 1) * (hid + 1) * sizeof(float), cudaMemcpyDeviceToHost);

  cudaFree(input_cuda);
  cudaFree(output_hidden_cuda);
  cudaFree(input_hidden_cuda);
  cudaFree(hidden_partial_sum);
  cudaFree(input_prev_weights_cuda);
  cudaFree(hidden_delta_cuda);

  free(partial_sum);
  free(input_weights_one_dim);
  free(input_weights_prev_one_dim);

#endif   

}

////////////////////////////////////////////////////////////////////////////////
外部无效bpnn_层前方（浮球*l1、浮球*l2、浮球**接头、内部n1、内部n2）；
外部无效bpnn_输出错误（浮点*增量，浮点*目标，浮点*输出，整数nj，浮点*错误）；
外部无效bpnn_隐藏错误（浮点*增量h，整数nh，浮点*增量o，整数编号，浮点**谁，浮点*隐藏，浮点*错误）；
外部无效bpnn_调整_权重（浮动*增量、整数ndelta、浮动*ly、整数nly、浮动**w、浮动**oldw）；
外部内部设置（内部argc，字符**argv）；
外部浮点**alloc_2d_dbl（int m，int n）；
外部浮动挤压（浮动x）；
双gettime（）{
结构时间值t；
gettimeofday（&t，NULL）；
返回t.tv_sec+t.tv_usec*1e-6；
}
无符号整数线程数=0；
无符号整数块=0；
////////////////////////////////////////////////////////////////////////////////
//主程序
////////////////////////////////////////////////////////////////////////////////
int
主（内部argc，字符**argv）
{
设置（argc、argv）；
}
无效bpnn_列_内核（bpnn*net，float*eo，float*eh）
{
int-in，hid，out；
浮出错误，隐藏错误；
in=net->input\n；
hid=网络->隐藏\u n；
输出=净->输出\u n；
#ifdef GPU
int m=0；
浮点*输入\隐藏\ cuda；
浮点*输入_cuda；
浮点*输出\隐藏\ cuda；
浮动*部分和；
浮动*隐藏部分和；
浮动*隐藏_delta_cuda；
浮动*输入\上一个\权重\ cuda；
浮点数；
浮动*输入权重一个尺寸；
浮动*输入权重上一个维度；
块数=英寸/16；
dim3网格（1，num_块）；
dim3螺纹（16,16）；
输入权重大小=（浮点*）malloc（（in+1）*（hid+1）*大小（浮点））；
输入权重上一个维度=（浮动*）malloc（（in+1）*（hid+1）*sizeof（浮动））；
部分和=（浮点*）malloc（块数*宽度*大小（浮点））；
//添加此预处理阶段是为了使用二维net->inputweights纠正错误memcopy的错误
对于（int k=0；k输入上一个权重[k][j]；
m++；
}
}
cudamaloc（（void**）和input_cuda，（in+1）*sizeof（float））；
cudamaloc（（void**）和output_hidden_cuda，（hid+1）*sizeof（float））；
cudamaloc（（void**）和input_hidden_cuda，（in+1）*（hid+1）*sizeof（float））；
cudamaloc（（void**）和hidden_partial_sum，num_blocks*WIDTH*sizeof（float））；
#恩迪夫
#ifdef中央处理器
printf（“执行CPU计算”）；
bpnn\u层向前（网络->输入\u单位，网络->隐藏\u单位，网络->输入\u权重，输入，隐藏）；
#恩迪夫
#ifdef GPU
printf（“执行GPU计算”）；
//printf（“in=%d，hid=%d，numblocks=%d\n”，in，hid，num_块）；
cudaMemcpy（输入单位，网络->输入单位，（单位+1）*大小（浮动），cudaMemcpyHostToDevice）；
cudaMemcpy（输入隐藏cuda，输入权重一维，（in+1）*（hid+1）*大小（float），cudaMemcpyHostToDevice）；
bpnn_layer正向_CUDA>（输入_CUDA，
输出\u隐藏\u cuda，
输入\u隐藏\u cuda，
隐藏部分和，
在里面
隐藏）；
cudaThreadSynchronize（）；
cudaError_t error=cudaGetLastError（）；
如果（错误！=cudaSuccess）{
printf（“bpnn内核错误：%s\n”，cudaGetErrorString（错误））；
退出（退出失败）；
}
cudaMemcpy（部分和、隐藏部分和、块数*宽度*大小（浮点）、cudamemcpydevicetoost）；
对于（int j=1；j输入_权重[0][j]；
净->隐藏单位[j]=浮动（1.0/（1.0+exp（-sum））；
}
#恩迪夫
bpnn\u层向前（网络->隐藏单元，网络->输出单元，网络->隐藏权重，隐藏，输出）；
bpnn输出错误（净->输出增量，净->目标，净->输出单位，输出，输出错误和输出错误）；
bpnn\u隐藏的\u错误（网络->隐藏的\u增量，隐藏，网络->输出的\u增量，输出，网络->隐藏的\u权重，网络->隐藏的\u单位和隐藏的\u错误）；
bpnn调整权重（净->输出增量、输出、净->隐藏单位、隐藏、净->隐藏权重、净->隐藏上一个权重）；
#ifdef中央处理器
bpnn_调整_权重（净->隐藏的_增量，隐藏，净->输入单位，输入，净->输入_权重，净->输入_上一个权重）；
#恩迪夫
#ifdef GPU
cudamaloc（（无效**）和隐藏的增量（隐藏+1）*大小（浮动））；
cudamaloc（（void**）和输入上一个权重（in+1）*（hid+1）*大小（float））；
cudaMemcpy（隐藏的增量，网络->隐藏的增量，（hid+1）*大小（浮动），cudaMemcpyHostToDevice）；
cudaMemcpy（输入上一个权重，输入上一个权重，一个维度，（in+1）*（hid+1）*sizeof（float），cudaMemcpyHostToDevice）；
cudaMemcpy（输入隐藏cuda，输入权重一维，（in+1）*（hid+1）*大小（float），cudaMemcpyHostToDevice）；
bpnn调整权重（隐藏增量），
隐藏，
输入_cuda，
在里面
输入\u隐藏\u cuda，
输入\上一个\权重\ cuda
);
cudaMemcpy（net->input_units，input_cuda，（in+1）*sizeof（float），cudaMemcpyDeviceToHost）；
cudaMemcpy（输入加权值为一维，输入隐藏值为cuda（in+1）*（hid+1）*大小为浮点数，cudaMemcpyDeviceToHost）；
cudaFree（输入_cuda）；
cudaFree（输出\隐藏\ cuda）；
cudaFree（输入\隐藏\ cuda）；
cudaFree（隐藏部分和）；
cudaFree（输入上一个权重值）；
cudaFree（隐藏的三角洲）；
自由（部分和）；
自由（输入权重值）；
自由（输入\权重\上一个\尺寸）；
#恩迪夫
}

---

如果您需要更多信息或代码，请告诉我。提前谢谢！

这是链接器错误。ld是链接器，因此如果您收到以“ld returned 1 exit status”结尾的错误消息，则会告诉您这是链接器错误

错误