Example #1
0
int* SENNA_POS_forward(SENNA_POS *pos, const int *sentence_words, const int *sentence_caps, const int *sentence_suff, int sentence_size)
{
  int idx;
  //@AureDi sentence_size+pos->window_size-1: broad convolution			(pos->ll_word_size+pos->ll_caps_size+pos->ll_suff_size): feature length
  pos->input_state = SENNA_realloc(pos->input_state, sizeof(float), (sentence_size+pos->window_size-1)*(pos->ll_word_size+pos->ll_caps_size+pos->ll_suff_size));
  pos->output_state = SENNA_realloc(pos->output_state, sizeof(float), sentence_size*pos->output_state_size);
  
  SENNA_nn_lookup(pos->input_state,                                     pos->ll_word_size+pos->ll_caps_size+pos->ll_suff_size, pos->ll_word_weight, pos->ll_word_size, pos->ll_word_max_idx, sentence_words, sentence_size, pos->ll_word_padding_idx, (pos->window_size-1)/2);
  SENNA_nn_lookup(pos->input_state+pos->ll_word_size,                   pos->ll_word_size+pos->ll_caps_size+pos->ll_suff_size, pos->ll_caps_weight, pos->ll_caps_size, pos->ll_caps_max_idx, sentence_caps,  sentence_size, pos->ll_caps_padding_idx, (pos->window_size-1)/2);
  SENNA_nn_lookup(pos->input_state+pos->ll_word_size+pos->ll_caps_size, pos->ll_word_size+pos->ll_caps_size+pos->ll_suff_size, pos->ll_suff_weight, pos->ll_suff_size, pos->ll_suff_max_idx, sentence_suff,  sentence_size, pos->ll_suff_padding_idx, (pos->window_size-1)/2);

  for(idx = 0; idx < sentence_size; idx++)
  {
    SENNA_nn_linear(pos->hidden_state, pos->hidden_state_size, pos->l1_weight, pos->l1_bias, pos->input_state+idx*(pos->ll_word_size+pos->ll_caps_size+pos->ll_suff_size), pos->window_size*(pos->ll_word_size+pos->ll_caps_size+pos->ll_suff_size));
    SENNA_nn_hardtanh(pos->hidden_state, pos->hidden_state, pos->hidden_state_size);
    SENNA_nn_linear(pos->output_state+idx*pos->output_state_size, pos->output_state_size, pos->l2_weight, pos->l2_bias, pos->hidden_state, pos->hidden_state_size);
  }

  pos->labels = SENNA_realloc(pos->labels, sizeof(int), sentence_size);
  SENNA_nn_viterbi(pos->labels, pos->viterbi_score_init, pos->viterbi_score_trans, pos->output_state, pos->output_state_size, sentence_size);

  return pos->labels;
}
Example #2
0
int *SENNA_CHK_forward(SENNA_CHK *chk, const int *sentence_words,
                       const int *sentence_caps, const int *sentence_posl,
                       TonicSuiteApp app) {
  chk->input_state = SENNA_realloc(
      chk->input_state, sizeof(float),
      (app.pl.num + chk->window_size - 1) *
          (chk->ll_word_size + chk->ll_caps_size + chk->ll_posl_size));
  chk->output_state = SENNA_realloc(chk->output_state, sizeof(float),
                                    app.pl.num * chk->output_state_size);

  SENNA_nn_lookup(chk->input_state,
                  chk->ll_word_size + chk->ll_caps_size + chk->ll_posl_size,
                  chk->ll_word_weight, chk->ll_word_size, chk->ll_word_max_idx,
                  sentence_words, app.pl.num, chk->ll_word_padding_idx,
                  (chk->window_size - 1) / 2);
  SENNA_nn_lookup(chk->input_state + chk->ll_word_size,
                  chk->ll_word_size + chk->ll_caps_size + chk->ll_posl_size,
                  chk->ll_caps_weight, chk->ll_caps_size, chk->ll_caps_max_idx,
                  sentence_caps, app.pl.num, chk->ll_caps_padding_idx,
                  (chk->window_size - 1) / 2);
  SENNA_nn_lookup(chk->input_state + chk->ll_word_size + chk->ll_caps_size,
                  chk->ll_word_size + chk->ll_caps_size + chk->ll_posl_size,
                  chk->ll_posl_weight, chk->ll_posl_size, chk->ll_posl_max_idx,
                  sentence_posl, app.pl.num, chk->ll_posl_padding_idx,
                  (chk->window_size - 1) / 2);

  int input_size = chk->ll_word_size + chk->ll_caps_size + chk->ll_posl_size;

  app.pl.data = (char *)malloc(app.pl.num * (chk->window_size * input_size) *
                               sizeof(float));

  for (int idx = 0; idx < app.pl.num; idx++) {
    memcpy((char *)(app.pl.data +
                    idx * (chk->window_size) * (input_size) * sizeof(float)),
           (char *)(chk->input_state + idx * input_size),
           chk->window_size * input_size * sizeof(float));
  }

  if (app.djinn) {
    SOCKET_send(app.socketfd, (char *)app.pl.data,
                chk->window_size * input_size * sizeof(float) * app.pl.num,
                debug);
    SOCKET_receive(app.socketfd, (char *)(chk->output_state),
                   chk->output_state_size * sizeof(float) * app.pl.num, debug);

  } else {
    float loss;
    vector<Blob<float> *> in_blobs = app.net->input_blobs();
    in_blobs[0]->set_cpu_data((float *)app.pl.data);
    vector<Blob<float> *> out_blobs = app.net->ForwardPrefilled(&loss);
    memcpy((chk->output_state), out_blobs[0]->cpu_data(),
           app.pl.num * (chk->output_state_size) * sizeof(float));
  }

  chk->labels = SENNA_realloc(chk->labels, sizeof(int), app.pl.num);
  SENNA_nn_viterbi(chk->labels, chk->viterbi_score_init,
                   chk->viterbi_score_trans, chk->output_state,
                   chk->output_state_size, app.pl.num);

  return chk->labels;
}