def run_batch(self, session, testmode=False):
     if not testmode:
         feed = {}
         for feat in self.inputs_placeholder_dict.keys():
             feed[self.inputs_placeholder_dict[
                 feat]] = self.loader.inputs_train_batch[feat]
         feed[self.keep_prob] = self.opts.dropout_p
         feed[self.hidden_prob] = self.opts.hidden_p
         feed[self.input_keep_prob] = self.opts.input_dp
         train_op = self.train_op
         _, loss, accuracy = session.run(
             [train_op, self.loss, self.accuracy], feed_dict=feed)
         return loss, accuracy
     else:
         feed = {}
         for feat in self.inputs_placeholder_dict.keys():
             feed[self.inputs_placeholder_dict[
                 feat]] = self.loader.inputs_test_batch[feat]
         feed[self.keep_prob] = 1.0
         feed[self.hidden_prob] = 1.0
         feed[self.input_keep_prob] = 1.0
         if self.beam_size == 0:
             loss, accuracy, predictions, weight = session.run(
                 [self.loss, self.accuracy, self.predictions, self.weight],
                 feed_dict=feed)
             weight = weight.astype(bool)
             predictions = predictions[weight]
             return loss, accuracy, predictions
         else:
             predictions, scores, weight_beam, weight, back_pointers = session.run(
                 [
                     self.predictions, self.scores, self.weight_beam,
                     self.weight, self.back_pointers
                 ],
                 feed_dict=feed)
             weight = weight.astype(bool)
             weight_beam = weight_beam.astype(bool)
             predictions, scores, indices = back_track(
                 predictions, scores, back_pointers, weight_beam)
             ## predictions [batch_size, seq_len], scores [batch_size, seq_en], back_pointer [batch_size, seq_len-1]
             b = predictions.shape[0] / self.beam_size
             n = predictions.shape[1]
             predictions = predictions.reshape([b, -1])[:, :n]
             ## [bB, n] => [b, Bn]
             predictions = predictions[weight]
             scores = scores[weight_beam]
             return predictions, scores
Esempio n. 2
0
    def run_batch(self, session, testmode=False):
        if not testmode:
            feed = {}
            for placeholder, data in zip(self.inputs_placeholder_list,
                                         self.loader.inputs_train_batch):
                feed[placeholder] = data
            feed[self.keep_prob] = self.opts.dropout_p
            feed[self.hidden_prob] = self.opts.hidden_p
            feed[self.input_keep_prob] = self.opts.input_dp
            train_op = self.train_op
            #train_op = tf.no_op()
            _, loss, accuracy, predictions, global_loss, scores = session.run(
                [
                    train_op, self.loss, self.accuracy, self.predictions,
                    self.global_loss, self.scores
                ],
                feed_dict=feed)
            #scores = scores.T
            #for i in xrange(scores.shape[0]):
            #    print(i)
            #    print(scores[i, :])
            #for i in xrange(global_loss.shape[0]):
            #    print(i)
            #    print(global_loss[i, :])

            #for i in xrange(17):
            #    print(i)
            #    print(global_loss_test[i, :])
            #predictions = predictions.reshape([3, 4, 18])
            #for i in xrange(18):
            #    print(i)
            #    print(predictions[:, :, i])
            return loss, accuracy
        else:
            feed = {}
            for placeholder, data in zip(self.inputs_placeholder_list,
                                         self.loader.inputs_test_batch):
                feed[placeholder] = data
            feed[self.keep_prob] = 1.0
            feed[self.hidden_prob] = 1.0
            feed[self.input_keep_prob] = 1.0
            if self.beam_size == 0:
                loss, accuracy, predictions, weight = session.run(
                    [self.loss, self.accuracy, self.predictions, self.weight],
                    feed_dict=feed)
                weight = weight.astype(bool)
                predictions = predictions[weight]
                return loss, accuracy, predictions
            else:
                predictions, scores, weight_beam, weight, back_pointers, correct_so_far = session.run(
                    [
                        self.predictions, self.scores, self.weight_beam,
                        self.weight, self.back_pointers, self.correct_so_far
                    ],
                    feed_dict=feed)
                weight = weight.astype(bool)
                weight_beam = weight_beam.astype(bool)
                #predictions_test = predictions.reshape([3, 4, 18])
                #for i in xrange(17):
                #    print(i)
                #    print(np.sum(correct_so_far[i, :, :], axis=-1))
                #    print(predictions_test[:, :, i])
                #print(predictions_test.shape)
                #for i in xrange(18):
                #    print(i)
                #    print(predictions_test[:, :, i])
                #print(predictions_test.shape)
                predictions, scores, indices = back_track(
                    predictions, scores, back_pointers, weight_beam)
                ## predictions [batch_size, seq_len], scores [batch_size, seq_en], back_pointer [batch_size, seq_len-1]
                b = predictions.shape[0] / self.beam_size
                n = predictions.shape[1]
                #predictions = predictions.reshape([3, 4, 18])
                #for i in xrange(18):
                #    print(i)
                #    print(predictions[:, :, i])
                #print(predictions.shape)
                predictions = predictions.reshape([b, -1])[:, :n]
                ## [bB, n] => [b, Bn]
                predictions = predictions[weight]
                scores = scores[weight_beam]
                return predictions, scores