コード例 #1
0
    def predict(self, sess, dev, labels):
        predicted_sentences = []

        dev_processed, labels_processed = self.preprocess_sequence_data(
            dev, labels)
        prog = Progbar(target=1 +
                       int(len(dev_processed) / self.config.batch_size))
        # predict in batches
        for i, (enc_batch, dec_batch) in enumerate(
                minibatches(dev_processed,
                            labels_processed,
                            self.config.batch_size,
                            shuffle=False)):
            #print enc_batch.shape, dec_batch.shape
            feed = self.create_feed_dict(enc_batch, dec_batch)

            outputs = sess.run(self.test_op, feed_dict=feed)
            for j in range(outputs.shape[0]):
                sentence = [self.labels_vocab.id2tok[k] for k in outputs[j, :]]
                if "</s>" in sentence:
                    sentence = sentence[:sentence.index("</s>")]
                predicted = " ".join(sentence)
                print predicted
                predicted_sentences.append(predicted)
            prog.update(i + 1)

        return predicted_sentences
コード例 #2
0
    def predict(self, sess, dev):
        predicted_sentences = []

        dev_processed, labels_processed = self.preprocess_sequence_data(
            dev[0], dev[1])
        prog = Progbar(target=int(len(dev_processed) / self.config.batch_size))
        # predict in batches
        tot_loss = 0
        for i, (enc_batch, dec_batch) in enumerate(
                minibatches(dev_processed, labels_processed,
                            self.config.batch_size, False)):
            #print enc_batch.shape, dec_batch.shape
            feed = self.create_feed_dict(enc_batch, dec_batch)
            if self.beam_search != None:
                outputs = sess.run(self.test_op, feed_dict=feed)
            else:
                outputs, loss = sess.run([self.test_op, self.predict_loss],
                                         feed_dict=feed)
                #loss = 0
                #outputs = sess.run(self.test_op, feed_dict = feed)
                tot_loss += loss
            for j in range(outputs.shape[0]):
                predicted = self.construct_sentence(
                    outputs[j, :], dev[2][(i * self.config.batch_size) + j])
                predicted_sentences.append(predicted)
                #print predicted
            if self.beam_search != None:
                prog.update(i + 1)
            else:
                prog.update(i + 1, [("test loss", tot_loss / (i + 1))])
        print ""
        return predicted_sentences
コード例 #3
0
def eval(model, optimizer, criterion, post_process, validate_loader, output_path):
    """
    :param model:
    :param criterion:
    :param post_process:
    :param validate_loader:
    :return:
    """
    if not os.path.exists(output_path):
        os.makedirs(output_path)
    model.eval()
    with torch.no_grad():
        P, R, F1 =0, 0, 0
        for i, batch in enumerate(validate_loader):
            pbar = Progbar(target=len(validate_loader))
            # 数据进行转换和丢到gpu
            batch_size, _, img_h, img_w = batch['img'].shape
            for key, value in batch.items():
                if value is not None:
                    if isinstance(value, torch.Tensor):
                        batch[key] = value.cuda()
            preds = model(batch['img'])
            batch['shape'] = [(img_h, img_w)]*batch_size
            #(batch, nums, 4, 2)
            pred_boxes_batch, scores_batch = post_process(batch, preds, is_output_polygon=False)
            # print('boxes_batch.shape', boxes_batch)
            batch_pred_masks = get_mask(pred_boxes_batch, img_h, img_w)
            precision, recall, f1 = get_eval_f1_score(batch_pred_masks, batch['gt'])
            P += precision
            R += recall
            F1 += f1
            pbar.update(i + 1, values=[('P', P/(i+1)), ('R', R/(i+1)), ('F1', F1/(i+1))])
        save_model(model, optimizer, model_path=os.path.join(output_path,
                                                             'model_{}.pth'.format(str(round(F1/(i+1), 2)))),
                                                             distributed=False)
    def run_epoch(self, sess, train_examples, dev_set, train_examples_raw, dev_set_raw, epoch, last_epoch):
        prog = Progbar(target=1 + int(len(train_examples) / self.config.batch_size))
        curr_loss = 0.
        num_encountered = 0
        for i, batch in enumerate(minibatches(train_examples, self.config.batch_size)):
            loss = self.train_on_batch(sess, *batch)
            curr_loss += loss
            prog.update(i + 1, [("train loss", loss)])
            if self.report: self.report.log_train_loss(loss)
            num_encountered +=1
        # print curr_loss/num_encountered
        losses.append(curr_loss/num_encountered)
        epochs.append(epoch+1)
        print("")

        logger.info("Evaluating on development data")
        token_cm, metrics = self.evaluate(sess, dev_set, dev_set_raw)
        if last_epoch: 
            self.outputConfusionMatrix(token_cm.as_data())
        logger.debug("Token-level confusion matrix:\n" + token_cm.as_table())
        logger.debug("Token-level scores:\n" + token_cm.summary())
        logger.info("Accuracy: %.2f", metrics[1])
        logger.info("Error: %.2f", metrics[0])

        return metrics[0], metrics[1]
コード例 #5
0
    def run_epoch(self, sess, train_examples, dev_set, train_examples_raw,
                  dev_set_raw):
        global losses
        global cm_latest
        prog = Progbar(target=1 +
                       int(len(train_examples) / self.config.batch_size))
        curr_loss = 0.
        num_encountered = 0

        minibatches = generate_minibatches(train_examples,
                                           self.config.batch_size, 1)
        for i, batch in enumerate(minibatches):
            loss = self.train_on_batch(sess, *batch)
            prog.update(i + 1, [("train loss", loss)])
            curr_loss += loss
            num_encountered += 1
            if self.report: self.report.log_train_loss(loss)

        losses.append(curr_loss / num_encountered)

        print("")

        logger.info("Evaluating on development data")
        token_cm, metrics = self.evaluate(sess, dev_set, dev_set_raw)
        cm_latest = token_cm

        logger.debug("Token-level confusion matrix:\n" + token_cm.as_table())
        logger.debug("Token-level errors:\n" + token_cm.summary())
        logger.info("Accuracy: %.2f", metrics[1])
        logger.info("Error: %.2f", metrics[0])

        return metrics[0], metrics[1]
コード例 #6
0
 def run_epoch(self, sess, train, labels, dev=None, dev_labels=None):
     prog = Progbar(target=1 + int(len(train) / self.config.batch_size))
     for i, (enc_batch, dec_batch) in enumerate(
             minibatches(train, labels, self.config.batch_size)):
         loss = self.train_on_batch(sess, enc_batch, dec_batch)
         prog.update(i + 1, [("train loss", loss)])
     logger.info("Finished Epoch! Running Dev tests")
     if dev != None and dev_labels != None:
         return self.dev_loss(sess, dev, dev_labels)
     return loss
    def output(self, sess, inputs_raw, inputs=None):
        if inputs is None:
            inputs = self.preprocess_sequence_data(self.helper.vectorize(inputs_raw))

        preds = []
        prog = Progbar(target=1 + int(len(inputs) / self.config.batch_size))
        for i, batch in enumerate(minibatches(inputs, self.config.batch_size, shuffle=False)):
            batch = batch[:1] + batch[2:]
            preds_ = self.predict_on_batch(sess, *batch)
            preds += list(preds_)
            prog.update(i + 1, [])
        return self.consolidate_predictions(inputs_raw, inputs, preds)
コード例 #8
0
    def run_epoch(self, sess, train, labels):
        prog = Progbar(target=1 + int(len(train) / self.config.batch_size))
        losses, grad_norms = [], []
        for i, (enc_batch, dec_batch) in enumerate(
                minibatches(train, labels, self.config.batch_size)):
            #print batch
            loss = self.train_on_batch(sess, enc_batch, dec_batch)
            #losses.append(loss)
            #grad_norms.append(grad_norm)
            #loss = 1
            prog.update(i + 1, [("train loss", loss)])

        return loss
コード例 #9
0
 def dev_loss(self, sess, dev_processed, labels_processed):
     prog = Progbar(target=1 +
                    int(len(dev_processed) / self.config.batch_size))
     tot_loss = 0
     for i, (enc_batch, dec_batch) in enumerate(
             minibatches(dev_processed,
                         labels_processed,
                         self.config.batch_size,
                         shuffle=False)):
         feed = self.create_feed_dict(enc_batch, labels_batch=dec_batch)
         _, loss = sess.run([self.test_op, self.predict_loss],
                            feed_dict=feed)
         tot_loss += loss
         prog.update(i + 1, [("dev loss", tot_loss)])
     return tot_loss
コード例 #10
0
    def output(self, sess, inputs_raw, inputs):
        """
        Reports the output of the model on examples (uses helper to featurize each example).
        """
        # always require valid inputs arg
        # if inputs is None:
        #     inputs = self.preprocess_sequence_data(self.helper.vectorize(inputs_raw))

        preds = []
        prog = Progbar(target=1 + int(len(inputs) / self.config.batch_size))
        for i, batch in enumerate(
                minibatches(inputs, self.config.batch_size, shuffle=False)):
            # Ignore predict
            batch = batch[:2] + batch[3:]
            preds_ = self.predict_on_batch(sess, *batch)
            preds += list(preds_)
            prog.update(i + 1, [])
        return self.consolidate_predictions(inputs_raw, inputs, preds)
コード例 #11
0
    def run_epoch(self, sess, train_examples, dev_set, train_examples_raw,
                  dev_set_raw):
        prog = Progbar(target=1 +
                       int(len(train_examples) / self.config.batch_size))
        for i, batch in enumerate(
                minibatches(train_examples, self.config.batch_size)):
            loss = self.train_on_batch(sess, *batch)
            prog.update(i + 1, [("train loss", loss)])
            if self.report: self.report.log_train_loss(loss)
        print("")

        logger.info("Evaluating on development data")
        token_cm, entity_scores = self.evaluate(sess, dev_set, dev_set_raw)
        logger.debug("Token-level confusion matrix:\n" + token_cm.as_table())
        logger.debug("Token-level scores:\n" + token_cm.summary())
        logger.info("Entity level P/R/F1: %.2f/%.2f/%.2f", *entity_scores)

        f1 = entity_scores[-1]
        return f1
コード例 #12
0
    def run_epoch(self, sess, train_examples, dev_set, train_examples_raw, dev_set_raw, epoch):
        prog = Progbar(target=1 + int(len(train_examples) / self.config.batch_size))
        curr_loss = 0.
        num_encountered = 0
        for i, batch in enumerate(minibatches(train_examples, self.config.batch_size)):
            loss = self.train_on_batch(sess, *batch)
            prog.update(i + 1, [("train loss", loss)])
            curr_loss += loss
            num_encountered += 1
            if self.report: self.report.log_train_loss(loss)
        train_loss.append(curr_loss/num_encountered)
        
        print("")

        logger.info("Evaluating on development data")
        divergence = self.evaluate(sess, dev_set, dev_set_raw)
        logger.info("KL divergence: %.2f", divergence)

        dev_loss.append(divergence)
        return divergence
コード例 #13
0
ファイル: model.py プロジェクト: ryanholmdahl/cs231n
 def run_epoch(self, sess, train_examples, dev_set, logfile=None):
     prog = Progbar(target=1 +
                    train_examples[0].shape[0] / self.config.batch_size)
     for i, (inputs_batch, outputs_batch) in enumerate(
             minibatches(train_examples, self.config.batch_size)):
         loss = self.train_on_batch(sess,
                                    inputs_batch,
                                    outputs_batch,
                                    get_loss=True)
         prog.update(i + 1, [("train loss", loss)])
     print("")
     print("Evaluating on train set...")
     train_loss = self.eval_batches(sess, train_examples,
                                    self.config.n_eval_batches)
     print("Train Loss: {0:.6f}".format(train_loss))
     print("Evaluating on dev set...")
     dev_loss = self.eval_batches(sess, dev_set, self.config.n_eval_batches)
     print("Dev Loss: {0:.6f}".format(dev_loss))
     logfile.write(",{0:.5f},{1:.5f}\n".format(float(train_loss),
                                               float(dev_loss)))
     return dev_loss
コード例 #14
0
def train(model, optimizer, epochs, criterion, train_loader, config, post_process, validate_loader,output_path):
    for epoch_index in range(epochs):
        model.train()
        pbar = Progbar(target=len(train_loader))
        index_train = epoch_index * len(train_loader)
        train_loss = 0.0
        P, R, F1 = 0, 0, 0
        for batch_index, batch in enumerate(train_loader):
            batch_index_ = batch_index
            batch_index_ += index_train
            # lr = optimizer.param_groups[0]['lr']
            lr = ajust_learning_tri(optimizer, batch_index_, step_size=len(train_loader) * 8)
            # 数据进行转换和丢到gpu
            for key, value in batch.items():
                if value is not None:
                    if isinstance(value, torch.Tensor):
                        batch[key] = value.cuda()
            preds = model(batch['img'])
            loss_dict = criterion(preds, batch)
            # backward
            optimizer.zero_grad()
            loss_dict['loss'].backward()
            optimizer.step()

            precision, recall, f1 = get_f1_score(preds[:, 0, :, :], batch['shrink_map'], batch['shrink_mask'],
                                                 config['post_processing']['args']['thresh'])
            train_loss += loss_dict['loss'].item()
            P += precision
            R += recall
            F1 += f1

            pbar.update(batch_index + 1, values=[('loss', train_loss / (batch_index + 1)),
                                                 ('P', P / (batch_index + 1)),
                                                 ('R', R / (batch_index + 1)),
                                                 ('F1', F1 / (batch_index + 1)),
                                                 ('epoch:', epoch_index)])
            lr_list.append(lr)

        eval(model, optimizer, criterion, post_process, validate_loader, output_path)
コード例 #15
0
ファイル: qa_model.py プロジェクト: kevinlu1211/QASystem
    def run_epoch(self,
                  session,
                  epoch_num,
                  training_set,
                  vocab,
                  validation_set,
                  sample_size=400):
        set_num = len(training_set)
        batch_size = self.config.batch_size
        batch_num = int(np.ceil(set_num * 1.0 / batch_size))
        sample_size = 400

        prog = Progbar(target=batch_num)
        avg_loss = 0
        for i, batch in enumerate(
                minibatches(training_set,
                            self.config.batch_size,
                            shuffle=False)):
            global_batch_num = batch_num * epoch_num + i
            _, summary, loss = self.optimize(session, batch)
            prog.update(i + 1, [("training loss", loss)])
            if self.config.tensorboard and global_batch_num % self.config.log_batch_num == 0:
                self.train_writer.add_summary(summary, global_batch_num)
            if (i + 1) % self.config.log_batch_num == 0:
                logging.info('')
                self.evaluate_answer(session,
                                     training_set,
                                     vocab,
                                     sample=sample_size,
                                     log=True)
                self.evaluate_answer(session,
                                     validation_set,
                                     vocab,
                                     sample=sample_size,
                                     log=True)
            avg_loss += loss
        avg_loss /= batch_num
        logging.info("Average training loss: {}".format(avg_loss))
        return avg_loss
コード例 #16
0
    def predict(self, sess, dev, labels):
        predicted_sentences = []

        dev_processed, labels_processed = self.preprocess_sequence_data(
            dev, labels)
        prog = Progbar(target=1 +
                       int(len(dev_processed) / self.config.batch_size))
        # predict in batches
        for i, (enc_batch, dec_batch) in enumerate(
                minibatches(dev_processed,
                            labels_processed,
                            self.config.batch_size,
                            shuffle=False)):
            #print enc_batch.shape, dec_batch.shape
            feed = self.create_feed_dict(enc_batch, dec_batch)

            outputs = sess.run(self.test_op, feed_dict=feed)
            for j in range(outputs.shape[0]):
                predicted = self.construct_sentence(outputs[j, :])
                #print predicted
                predicted_sentences.append(predicted)
            prog.update(i + 1)

        return predicted_sentences
コード例 #17
0
ファイル: qa_model.py プロジェクト: kevinlu1211/QASystem
    def validate(self, sess, valid_dataset):
        """
        Iterate through the validation dataset and determine what
        the validation cost is.

        This method calls self.test() which explicitly calculates validation cost.

        How you implement this function is dependent on how you design
        your data iteration function

        :return:
        """
        batch_num = int(
            np.ceil(len(valid_dataset) * 1.0 / self.config.batch_size))
        prog = Progbar(target=batch_num)
        avg_loss = 0
        for i, batch in enumerate(
                minibatches(valid_dataset, self.config.batch_size)):
            loss = self.test(sess, batch)[0]
            prog.update(i + 1, [("validation loss", loss)])
            avg_loss += loss
        avg_loss /= batch_num
        logging.info("Average validation loss: {}".format(avg_loss))
        return avg_loss
コード例 #18
0
def train(student_model, teacher_model, optimizer, epochs, student_criterion,
          teacher_criterion, train_loader, config, post_process,
          validate_loader, output_path):
    for epoch_index in range(epochs):
        student_model.train()
        pbar = Progbar(target=len(train_loader))
        index_train = epoch_index * len(train_loader)
        train_loss = 0.0
        P, R, F1 = 0, 0, 0
        for batch_index, batch in enumerate(train_loader):
            batch_index_ = batch_index
            batch_index_ += index_train
            # lr = optimizer.param_groups[0]['lr']
            lr = ajust_learning_tri(optimizer,
                                    batch_index_,
                                    step_size=len(train_loader) * 8)
            # 数据进行转换和丢到gpu
            for key, value in batch.items():
                if value is not None:
                    if isinstance(value, torch.Tensor):
                        batch[key] = value.cuda()
            student_preds = student_model(batch['img'])

            loss_dict = {}
            # KD loss
            if teacher_model is not None:
                teacher_model.eval()
                with torch.no_grad():
                    # (b,2,h,w)
                    teacher_outputs = teacher_model(
                        batch['img']
                    )  # shrink_maps, threshold_maps, binary_maps

                kd_loss_dict = teacher_criterion(student_preds,
                                                 teacher_outputs, batch)
                loss_dict = {**kd_loss_dict}

            gt_loss_dict = student_criterion(student_preds, batch)
            loss_dict = {**gt_loss_dict, **loss_dict}
            # backward
            total_losses = sum(loss_ for loss_ in loss_dict.values())
            optimizer.zero_grad()
            total_losses.backward()
            optimizer.step()

            precision, recall, f1 = get_f1_score(
                student_preds[:, 0, :, :], batch['shrink_map'],
                batch['shrink_mask'],
                config['post_processing']['args']['thresh'])
            train_loss += total_losses.item()
            P += precision
            R += recall
            F1 += f1

            pbar.update(batch_index + 1,
                        values=[('loss', train_loss / (batch_index + 1)),
                                ('P', P / (batch_index + 1)),
                                ('R', R / (batch_index + 1)),
                                ('F1', F1 / (batch_index + 1)),
                                ('epoch:', epoch_index)])
            lr_list.append(lr)
        if (epoch_index + 1) % 10 == 0:
            eval(student_model, optimizer, post_process, validate_loader,
                 output_path)