Merge branch 'task_update' into develop

demo/image-classification/img_classifier.py

@@ -9,7 +9,7 @@ import numpy as np
 # yapf: disable
 parser = argparse.ArgumentParser(__doc__)
 parser.add_argument("--num_epoch",      type=int,   default=1,                          help="Number of epoches for fine-tuning.")
-parser.add_argument("--use_gpu",        type=bool,  default=False,                      help="Whether use GPU for fine-tuning.")
+parser.add_argument("--use_gpu",        type=bool,  default=True,                      help="Whether use GPU for fine-tuning.")
 parser.add_argument("--checkpoint_dir", type=str,   default="paddlehub_finetune_ckpt",  help="Path to save log data.")
 parser.add_argument("--batch_size",     type=int,   default=16,                         help="Total examples' number in batch for training.")
 parser.add_argument("--module",         type=str,   default="resnet50",                 help="Module used as feature extractor.")
@@ -51,11 +51,9 @@ def finetune(args):
         dataset=dataset)
 
     feature_map = output_dict["feature_map"]
-    task = hub.create_img_cls_task(
-        feature=feature_map, num_classes=dataset.num_labels)
 
     img = input_dict["image"]
-    feed_list = [img.name, task.variable('label').name]
+    feed_list = [img.name]
 
     config = hub.RunConfig(
         use_cuda=args.use_gpu,
@@ -65,8 +63,13 @@ def finetune(args):
         checkpoint_dir=args.checkpoint_dir,
         strategy=hub.finetune.strategy.DefaultFinetuneStrategy())
 
-    hub.finetune_and_eval(
-        task, feed_list=feed_list, data_reader=data_reader, config=config)
+    task = hub.ImageClassifierTask(
+        data_reader=data_reader,
+        feed_list=feed_list,
+        feature=feature_map,
+        num_classes=dataset.num_labels,
+        config=config)
+    task.finetune_and_eval()
 
 
 if __name__ == "__main__":

demo/image-classification/predict.py

@@ -10,6 +10,7 @@ import numpy as np
 parser = argparse.ArgumentParser(__doc__)
 parser.add_argument("--use_gpu",        type=bool,  default=False,                      help="Whether use GPU for predict.")
 parser.add_argument("--checkpoint_dir", type=str,   default="paddlehub_finetune_ckpt",  help="Path to save log data.")
+parser.add_argument("--batch_size",     type=int,   default=16,                         help="Total examples' number in batch for training.")
 parser.add_argument("--module",         type=str,   default="resnet50",                 help="Module used as a feature extractor.")
 parser.add_argument("--dataset",        type=str,   default="flowers",                  help="Dataset to finetune.")
 # yapf: enable.
@@ -25,6 +26,8 @@ module_map = {
 
 
 def predict(args):
+    module = hub.Module(name=args.module)
+    input_dict, output_dict, program = module.context(trainable=True)
 
     if args.dataset.lower() == "flowers":
         dataset = hub.dataset.Flowers()
@@ -39,45 +42,43 @@ def predict(args):
     else:
         raise ValueError("%s dataset is not defined" % args.dataset)
 
-    label_map = dataset.label_dict()
-    num_labels = len(label_map)
-
-    module = hub.Module(name=args.module)
-    input_dict, output_dict, program = module.context()
-
     data_reader = hub.reader.ImageClassificationReader(
         image_width=module.get_expected_image_width(),
         image_height=module.get_expected_image_height(),
         images_mean=module.get_pretrained_images_mean(),
         images_std=module.get_pretrained_images_std(),
-        dataset=None)
+        dataset=dataset)
 
-    img = input_dict["image"]
     feature_map = output_dict["feature_map"]
-    task = hub.create_img_cls_task(feature=feature_map, num_classes=num_labels)
+
     img = input_dict["image"]
     feed_list = [img.name]
 
-    with fluid.program_guard(task.inference_program()):
-        place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
-        exe = fluid.Executor(place)
-        pretrained_model_dir = os.path.join(args.checkpoint_dir, "best_model")
-        if not os.path.exists(pretrained_model_dir):
-            hub.logger.error(
-                "pretrained model dir %s didn't exist" % pretrained_model_dir)
-            exit(1)
-        fluid.io.load_persistables(exe, pretrained_model_dir)
-        feeder = fluid.DataFeeder(feed_list=feed_list, place=place)
-        data = ["test/test_img_roses.jpg", "test/test_img_daisy.jpg"]
+    config = hub.RunConfig(
+        use_cuda=args.use_gpu,
+        batch_size=args.batch_size,
+        enable_memory_optim=False,
+        checkpoint_dir=args.checkpoint_dir,
+        strategy=hub.finetune.strategy.DefaultFinetuneStrategy())
 
-        predict_reader = data_reader.data_generator(
-            phase="predict", batch_size=1, data=data)
-        for index, batch in enumerate(predict_reader()):
-            result, = exe.run(
-                feed=feeder.feed(batch), fetch_list=[task.variable('probs')])
-            predict_result = label_map[np.argsort(result[0])[::-1][0]]
-            print("input %i is %s, and the predict result is %s" %
-                  (index, data[index], predict_result))
+    task = hub.ClassifierTask(
+        data_reader=data_reader,
+        feed_list=feed_list,
+        feature=feature_map,
+        num_classes=dataset.num_labels,
+        config=config)
+
+    data = ["./test/test_img_daisy.jpg", "./test/test_img_roses.jpg"]
+    label_map = dataset.label_dict()
+    for result in task.predict(data=data):
+        result = np.argmax(result, axis=2)
+        index = 0
+        for batch in result:
+            for predict_result in batch:
+                index += 1
+                predict_result = label_map[predict_result]
+                print("input %i is %s, and the predict result is %s" %
+                      (index, data[index - 1], predict_result))
 
 
 if __name__ == "__main__":

paddlehub/__init__.py

@@ -42,11 +42,10 @@ from .module.manager import default_module_manager
 
 from .io.type import DataType
 
-from .finetune.task import Task
-from .finetune.task import create_seq_label_task
-from .finetune.task import create_text_cls_task
-from .finetune.task import create_img_cls_task
-from .finetune.finetune import finetune_and_eval
+from .finetune.task import ClassifierTask
+from .finetune.task import TextClassifierTask
+from .finetune.task import ImageClassifierTask
+from .finetune.task import SequenceLabelTask
 from .finetune.config import RunConfig
 from .finetune.strategy import AdamWeightDecayStrategy
 from .finetune.strategy import DefaultStrategy

paddlehub/common/paddle_helper.py

@@ -143,7 +143,11 @@ def from_module_attr_to_param(module_attr):
     return param
 
 
-def connect_program(pre_program, next_program, input_dict=None, inplace=True):
+def connect_program(pre_program,
+                    next_program,
+                    input_dict=None,
+                    inplace=True,
+                    need_log=True):
     def _copy_vars_and_ops_in_blocks(from_block, to_block):
         for var in from_block.vars:
             var = from_block.var(var)
@@ -199,7 +203,8 @@ def connect_program(pre_program, next_program, input_dict=None, inplace=True):
                 outputs={'Out': output_var})
 
     block_map = {0: 0}
-    logger.info("Connect program's input tensor")
+    if need_log:
+        logger.info("Connect program's input tensor")
     for index, block in enumerate(next_program.blocks):
         if block.idx == 0:
             _copy_vars_and_ops_in_blocks(block, output_program.global_block())
@@ -211,7 +216,8 @@ def connect_program(pre_program, next_program, input_dict=None, inplace=True):
             new_block = output_program._create_block(
                 parent_idx=block_map[block.parent_idx])
             _copy_vars_and_ops_in_blocks(block, new_block)
-    logger.info("Connect program's input tensor done")
+    if need_log:
+        logger.info("Connect program's input tensor done")
     return output_program
 
 

paddlehub/finetune/checkpoint.py

@@ -27,7 +27,11 @@ from paddlehub.common.logger import logger
 CKPT_FILE_NAME = "ckpt.meta"
 
 
-def load_checkpoint(checkpoint_dir, exe):
+def load_checkpoint(checkpoint_dir,
+                    exe,
+                    main_program=fluid.default_main_program(),
+                    startup_program=fluid.default_startup_program()):
+
     ckpt_meta_path = os.path.join(checkpoint_dir, CKPT_FILE_NAME)
     logger.info("Try loading checkpoint from {}".format(ckpt_meta_path))
     if os.path.exists(ckpt_meta_path):
@@ -35,7 +39,7 @@ def load_checkpoint(checkpoint_dir, exe):
         with open(ckpt_meta_path, "rb") as f:
             ckpt.ParseFromString(f.read())
 
-        fluid.io.load_persistables(exe, ckpt.latest_model_dir)
+        fluid.io.load_persistables(exe, ckpt.latest_model_dir, main_program)
 
         logger.info("PaddleHub model checkpoint loaded. current_epoch={}, "
                     "global_step={}".format(ckpt.current_epoch,
@@ -48,18 +52,24 @@ def load_checkpoint(checkpoint_dir, exe):
         logger.info(
             "PaddleHub model checkpoint not found, start training from scratch..."
         )
-        exe.run(fluid.default_startup_program())
+        exe.run(startup_program)
 
         return current_epoch, global_step
 
 
-def save_checkpoint(checkpoint_dir, current_epoch, global_step, exe):
+def save_checkpoint(checkpoint_dir,
+                    current_epoch,
+                    global_step,
+                    exe,
+                    main_program=fluid.default_main_program()):
+
     ckpt_meta_path = os.path.join(checkpoint_dir, CKPT_FILE_NAME)
     ckpt = checkpoint_pb2.CheckPoint()
 
     model_saved_dir = os.path.join(checkpoint_dir, "step_%d" % global_step)
     logger.info("Saving model checkpoint to {}".format(model_saved_dir))
-    fluid.io.save_persistables(exe, dirname=model_saved_dir)
+    fluid.io.save_persistables(
+        exe, dirname=model_saved_dir, main_program=main_program)
 
     ckpt.current_epoch = current_epoch
     ckpt.global_step = global_step

paddlehub/finetune/config.py

@@ -30,6 +30,7 @@ class RunConfig(object):
     def __init__(self,
                  log_interval=10,
                  eval_interval=100,
+                 use_pyreader=False,
                  save_ckpt_interval=None,
                  use_cuda=True,
                  checkpoint_dir=None,
@@ -45,6 +46,7 @@ class RunConfig(object):
         self._checkpoint_dir = checkpoint_dir
         self._num_epoch = num_epoch
         self._batch_size = batch_size
+        self._use_pyreader = use_pyreader
         if strategy is None:
             self._strategy = DefaultStrategy()
         else:
@@ -94,3 +96,7 @@ class RunConfig(object):
     @property
     def enable_memory_optim(self):
         return self._enable_memory_optim
+
+    @property
+    def use_pyreader(self):
+        return self._use_pyreader

paddlehub/finetune/evaluate.py

@@ -26,95 +26,6 @@ from paddlehub.common.logger import logger
 import paddlehub as hub
 
 
-def evaluate_cls_task(task, data_reader, feed_list, phase="test", config=None):
-    logger.info("Evaluation on {} dataset start".format(phase))
-    test_program = task.test_program()
-    main_program = task.main_program()
-    loss = task.variable("loss")
-    accuracy = task.variable("accuracy")
-    batch_size = config.batch_size
-    place, dev_count = hub.common.get_running_device_info(config)
-    exe = fluid.Executor(place=place)
-    with fluid.program_guard(test_program):
-        data_feeder = fluid.DataFeeder(feed_list=feed_list, place=place)
-        num_eval_examples = acc_sum = loss_sum = 0
-        test_reader = data_reader.data_generator(
-            batch_size=batch_size, phase=phase)
-        eval_time_begin = time.time()
-        eval_step = 0
-        for batch in test_reader():
-            num_batch_examples = len(batch)
-            eval_step += 1
-            loss_v, accuracy_v = exe.run(
-                feed=data_feeder.feed(batch),
-                fetch_list=[loss.name, accuracy.name])
-            num_eval_examples += num_batch_examples
-            if num_eval_examples % 10000 == 0:
-                logger.info("{} examples evaluated.".format(num_eval_examples))
-            acc_sum += accuracy_v * num_batch_examples
-            loss_sum += loss_v * num_batch_examples
-        eval_time_used = time.time() - eval_time_begin
-
-        avg_loss = loss_sum / num_eval_examples
-        avg_acc = acc_sum / num_eval_examples
-        eval_speed = eval_step / eval_time_used
-
-    logger.info(
-        "[%s dataset evaluation result] loss=%.5f acc=%.5f [step/sec: %.2f]" %
-        (phase, avg_loss, avg_acc, eval_speed))
-
-    return avg_loss, avg_acc, eval_speed
-
-
-def evaluate_seq_label_task(task,
-                            data_reader,
-                            feed_list,
-                            phase="test",
-                            config=None):
-    fetch_list = [
-        task.variable("labels").name,
-        task.variable("infers").name,
-        task.variable("seq_len").name,
-        task.variable("loss").name
-    ]
-    logger.info("Evaluation on {} dataset start".format(phase))
-    test_program = task.test_program()
-    batch_size = config.batch_size
-    place, dev_count = hub.common.get_running_device_info(config)
-    exe = fluid.Executor(place=place)
-    # calculate the num of label from probs variable shape
-    num_labels = task.variable("probs").shape[1]
-    with fluid.program_guard(test_program):
-        data_feeder = fluid.DataFeeder(feed_list=feed_list, place=place)
-        num_eval_examples = acc_sum = loss_sum = 0
-        test_reader = data_reader.data_generator(
-            batch_size=batch_size, phase=phase)
-        eval_time_begin = time.time()
-        eval_step = 0
-        total_label, total_infer, total_correct = 0.0, 0.0, 0.0
-        for batch in test_reader():
-            num_batch_examples = len(batch)
-            eval_step += 1
-            np_labels, np_infers, np_lens, _ = exe.run(
-                feed=data_feeder.feed(batch), fetch_list=fetch_list)
-            label_num, infer_num, correct_num = chunk_eval(
-                np_labels, np_infers, np_lens, num_labels, dev_count)
-
-            total_infer += infer_num
-            total_label += label_num
-            total_correct += correct_num
-
-        precision, recall, f1 = calculate_f1(total_label, total_infer,
-                                             total_correct)
-        eval_time_used = time.time() - eval_time_begin
-        eval_speed = eval_step / eval_time_used
-        logger.info(
-            "[%s evaluation] F1-Score=%f, precision=%f, recall=%f [step/sec: %.2f]"
-            % (phase, f1, precision, recall, eval_speed))
-
-    return f1, precision, recall
-
-
 # Sequence label evaluation functions
 def chunk_eval(np_labels, np_infers, np_lens, tag_num, dev_count=1):
     def extract_bio_chunk(seq):

paddlehub/finetune/finetune.py

-#coding:utf-8
-# Copyright (c) 2019  PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import time
-
-import paddle
-import paddle.fluid as fluid
-import numpy as np
-from visualdl import LogWriter
-
-from paddlehub.common.logger import logger
-from paddlehub.common.utils import mkdir
-from paddlehub.finetune.config import RunConfig
-from paddlehub.finetune.strategy import AdamWeightDecayStrategy, DefaultStrategy
-from paddlehub.finetune.checkpoint import load_checkpoint, save_checkpoint
-from paddlehub.finetune.evaluate import evaluate_cls_task, evaluate_seq_label_task
-import paddlehub as hub
-
-
-def _do_memory_optimization(task, config):
-    if config.enable_memory_optim:
-        logger.info("Memory optimization start...")
-        task_var_name = task.metric_variable_names()
-        logger.info(
-            "Skip memory optimization on variables: {}".format(task_var_name))
-        optimize_time_begin = time.time()
-        fluid.memory_optimize(
-            input_program=fluid.default_main_program(),
-            # skip memory optimization on task metric variables
-            skip_opt_set=task_var_name)
-        time_used = time.time() - optimize_time_begin
-        logger.info("Memory optimization done! Time elapsed %f sec" % time_used)
-
-    # lower_mem, upper_mem, unit = fluid.contrib.memory_usage(
-    #     program=task.main_program(), batch_size=config.batch_size)
-    # logger.info("Theoretical memory usage in training: %.2f - %.2f %s" %
-    #             (lower_mem, upper_mem, unit)),
-
-
-def _finetune_seq_label_task(task,
-                             data_reader,
-                             feed_list,
-                             config=None,
-                             do_eval=False):
-    """
-    Finetune sequence labeling task, evaluate metric is F1, precision and recall
-
-    """
-    main_program = task.main_program()
-    startup_program = task.startup_program()
-    loss = task.variable("loss")
-    seq_len = task.variable("seq_len")
-
-    num_epoch = config.num_epoch
-    batch_size = config.batch_size
-    log_writer = LogWriter(
-        os.path.join(config.checkpoint_dir, "vdllog"), sync_cycle=1)
-
-    place, dev_count = hub.common.get_running_device_info(config)
-    with fluid.program_guard(main_program, startup_program):
-        exe = fluid.Executor(place=place)
-        data_feeder = fluid.DataFeeder(feed_list=feed_list, place=place)
-
-        # Select strategy
-        if isinstance(config.strategy, hub.AdamWeightDecayStrategy):
-            scheduled_lr = config.strategy.execute(loss, main_program,
-                                                   data_reader, config)
-        elif isinstance(config.strategy, hub.DefaultStrategy):
-            config.strategy.execute(loss)
-        #TODO: add more finetune strategy
-
-        _do_memory_optimization(task, config)
-
-        # Try to restore model training checkpoint
-        current_epoch, global_step = load_checkpoint(config.checkpoint_dir, exe)
-
-        best_eval_f1 = 0.0
-        train_time_used = 0
-        logger.info("PaddleHub finetune start")
-
-        exe.run(fluid.default_startup_program())
-
-        # add visualdl scalar
-        with log_writer.mode("train") as logw:
-            train_loss_scalar = logw.scalar(tag="Loss [train]")
-        with log_writer.mode("evaluate") as logw:
-            eval_f1_scalar = logw.scalar(tag="F1 [eval]")
-            eval_precision_scalar = logw.scalar(tag="Precision [eval]")
-            eval_recall_scalar = logw.scalar(tag="Recall [eval]")
-
-        # Finetune loop
-        for epoch in range(current_epoch, num_epoch + 1):
-            train_reader = data_reader.data_generator(
-                batch_size=batch_size, phase='train')
-            num_trained_examples = loss_sum = 0
-            for batch in train_reader():
-                num_batch_examples = len(batch)
-                train_time_begin = time.time()
-                loss_v = exe.run(
-                    feed=data_feeder.feed(batch), fetch_list=[loss.name])
-                train_time_used += time.time() - train_time_begin
-                global_step += 1
-                num_trained_examples += num_batch_examples
-                loss_sum += loss_v[0] * num_batch_examples
-
-                # log fintune status
-                if global_step % config.log_interval == 0:
-                    avg_loss = loss_sum / num_trained_examples
-                    speed = config.log_interval / train_time_used
-                    logger.info("step %d: loss=%.5f [step/sec: %.2f]" %
-                                (global_step, avg_loss, speed))
-                    train_loss_scalar.add_record(global_step, avg_loss)
-
-                    train_time_used = 0
-                    num_trained_examples = 0
-                    loss_sum = 0
-
-                if config.save_ckpt_interval and global_step % config.save_ckpt_interval == 0:
-                    # NOTE: current saved checkpoint machanism is not completed,
-                    # it can't restore correct dataset training status
-                    save_checkpoint(
-                        checkpoint_dir=config.checkpoint_dir,
-                        current_epoch=epoch,
-                        global_step=global_step,
-                        exe=exe)
-
-                if do_eval and global_step % config.eval_interval == 0:
-                    f1, precision, recall = evaluate_seq_label_task(
-                        task,
-                        data_reader,
-                        feed_list,
-                        phase="dev",
-                        config=config)
-                    eval_f1_scalar.add_record(global_step, f1)
-                    eval_precision_scalar.add_record(global_step, precision)
-                    eval_recall_scalar.add_record(global_step, recall)
-                    if f1 > best_eval_f1:
-                        best_eval_f1 = f1
-                        model_saved_dir = os.path.join(config.checkpoint_dir,
-                                                       "best_model")
-                        logger.info("best model saved to %s [best F1=%.5f]" %
-                                    (model_saved_dir, best_eval_f1))
-                        fluid.io.save_persistables(exe, dirname=model_saved_dir)
-
-        # NOTE: current saved checkpoint machanism is not completed, it can't
-        # resotre dataset training status
-        save_checkpoint(
-            checkpoint_dir=config.checkpoint_dir,
-            current_epoch=num_epoch + 1,
-            global_step=global_step,
-            exe=exe)
-
-        # Final evaluation
-        if do_eval:
-            evaluate_seq_label_task(
-                task, data_reader, feed_list, phase="dev", config=config)
-            evaluate_seq_label_task(
-                task, data_reader, feed_list, phase="test", config=config)
-        logger.info("PaddleHub finetune finished.")
-
-
-def _finetune_cls_task(task, data_reader, feed_list, config=None,
-                       do_eval=False):
-    main_program = task.main_program()
-    startup_program = task.startup_program()
-    loss = task.variable("loss")
-    accuracy = task.variable("accuracy")
-
-    num_epoch = config.num_epoch
-    batch_size = config.batch_size
-    log_writer = LogWriter(
-        os.path.join(config.checkpoint_dir, "vdllog"), sync_cycle=1)
-
-    place, dev_count = hub.common.get_running_device_info(config)
-    with fluid.program_guard(main_program, startup_program):
-        exe = fluid.Executor(place=place)
-        data_feeder = fluid.DataFeeder(feed_list=feed_list, place=place)
-
-        # select strategy
-        if isinstance(config.strategy, hub.AdamWeightDecayStrategy):
-            scheduled_lr = config.strategy.execute(loss, main_program,
-                                                   data_reader, config)
-        elif isinstance(config.strategy, hub.DefaultStrategy):
-            config.strategy.execute(loss)
-        #TODO: add more finetune strategy
-
-        _do_memory_optimization(task, config)
-
-        # Try to restore model training checkpoint
-        current_epoch, global_step = load_checkpoint(config.checkpoint_dir, exe)
-
-        best_eval_acc = 0.0
-        train_time_used = 0
-        logger.info("PaddleHub finetune start")
-
-        # add visualdl scalar
-        with log_writer.mode("train") as logw:
-            train_loss_scalar = logw.scalar(tag="Loss [train]")
-            train_acc_scalar = logw.scalar(tag="Accuracy [train]")
-        with log_writer.mode("evaluate") as logw:
-            eval_loss_scalar = logw.scalar(tag="Loss [eval]")
-            eval_acc_scalar = logw.scalar(tag="Accuracy [eval]")
-
-        exe.run(fluid.default_startup_program())
-
-        # Finetune loop
-        for epoch in range(current_epoch, num_epoch + 1):
-            train_reader = data_reader.data_generator(
-                batch_size=batch_size, phase='train')
-            num_trained_examples = acc_sum = loss_sum = 0
-            for batch in train_reader():
-                num_batch_examples = len(batch)
-                train_time_begin = time.time()
-                loss_v, accuracy_v = exe.run(
-                    feed=data_feeder.feed(batch),
-                    fetch_list=[loss.name, accuracy.name],
-                    return_numpy=False)
-                loss_v = np.array(loss_v)
-                accuracy_v = np.array(accuracy_v)
-                train_time_used += time.time() - train_time_begin
-                global_step += 1
-                num_trained_examples += num_batch_examples
-                acc_sum += accuracy_v * num_batch_examples
-                loss_sum += loss_v * num_batch_examples
-
-                # log fintune status
-                if global_step % config.log_interval == 0:
-                    avg_loss = loss_sum / num_trained_examples
-                    avg_acc = acc_sum / num_trained_examples
-                    speed = config.log_interval / train_time_used
-                    logger.info("step %d: loss=%.5f acc=%.5f [step/sec: %.2f]" %
-                                (global_step, avg_loss, avg_acc, speed))
-
-                    # record visualdl log
-                    train_loss_scalar.add_record(global_step, avg_loss)
-                    train_acc_scalar.add_record(global_step, avg_acc)
-
-                    train_time_used = 0
-                    num_trained_examples = acc_sum = loss_sum = 0
-
-                if config.save_ckpt_interval and global_step % config.save_ckpt_interval == 0:
-                    # NOTE: current saved checkpoint machanism is not completed,
-                    # it can't restore dataset training status
-                    save_checkpoint(
-                        checkpoint_dir=config.checkpoint_dir,
-                        current_epoch=epoch,
-                        global_step=global_step,
-                        exe=exe)
-
-                if do_eval and global_step % config.eval_interval == 0:
-                    eval_loss, eval_acc, eval_perf = evaluate_cls_task(
-                        task,
-                        data_reader,
-                        feed_list,
-                        phase="val",
-                        config=config)
-                    eval_loss_scalar.add_record(global_step, eval_loss)
-                    eval_acc_scalar.add_record(global_step, eval_acc)
-                    if eval_acc > best_eval_acc:
-                        best_eval_acc = eval_acc
-                        model_saved_dir = os.path.join(config.checkpoint_dir,
-                                                       "best_model")
-                        logger.info(
-                            "best model saved to %s [best accuracy=%.5f]" %
-                            (model_saved_dir, best_eval_acc))
-                        fluid.io.save_persistables(exe, dirname=model_saved_dir)
-
-        # NOTE: current saved checkpoint machanism is not completed, it can't
-        # resotre dataset training status
-        save_checkpoint(
-            checkpoint_dir=config.checkpoint_dir,
-            current_epoch=num_epoch + 1,
-            global_step=global_step,
-            exe=exe)
-
-        # Final evaluation
-        if do_eval:
-            evaluate_cls_task(
-                task, data_reader, feed_list, phase="dev", config=config)
-            evaluate_cls_task(
-                task, data_reader, feed_list, phase="test", config=config)
-        logger.info("PaddleHub finetune finished.")
-
-
-def finetune_and_eval(task, data_reader, feed_list, config=None):
-    if config is None:
-        config = RunConfig()
-
-    if not os.path.exists(config.checkpoint_dir):
-        mkdir(config.checkpoint_dir)
-
-    if task.task_type == "sequence_labeling":
-        _finetune_seq_label_task(
-            task, data_reader, feed_list, config, do_eval=True)
-    elif task.task_type == "image_classification" or task.task_type == "text_classification":
-        _finetune_cls_task(task, data_reader, feed_list, config, do_eval=True)

paddlehub/finetune/strategy.py

@@ -75,7 +75,7 @@ class DefaultStrategy(object):
             self.optimizer = fluid.optimizer.Adam(
                 learning_rate=self.learning_rate)
 
-    def execute(self, loss):
+    def execute(self, loss, data_reader, config):
         if self.optimizer is not None:
             self.optimizer.minimize(loss)
         else:
@@ -115,7 +115,8 @@ class AdamWeightDecayStrategy(DefaultStrategy):
     def weight_decay(self):
         return self._weight_decay
 
-    def execute(self, loss, main_program, data_reader, config):
+    def execute(self, loss, data_reader, config):
+        main_program = loss.block.program
         # calculate wamrup step
         dev_count = self._get_dev_count(config)
         data_reader.data_generator(
@@ -159,7 +160,7 @@ class DefaultFinetuneStrategy(DefaultStrategy):
         self._optimizer_name = optimizer_name
         self.regularization_coeff = regularization_coeff
 
-    def execute(self, loss):
+    def execute(self, loss, data_reader, config):
         # get pretrained parameters
         program = loss.block.program
         global_block = program.global_block()
@@ -188,7 +189,7 @@ class L2SPFinetuneStrategy(DefaultStrategy):
         self._optimizer_name = optimizer_name
         self.regularization_coeff = regularization_coeff
 
-    def execute(self, loss):
+    def execute(self, loss, data_reader, config):
         # get pretrained parameters
         program = loss.block.program
         global_block = program.global_block()

paddlehub/reader/nlp_reader.py

@@ -19,16 +19,17 @@ from __future__ import print_function
 
 import csv
 import json
+import numpy as np
 import platform
 import six
 import sys
 from collections import namedtuple
 
 import paddle
-import numpy as np
 
 from paddlehub.reader import tokenization
 from paddlehub.common.logger import logger
+from paddlehub.dataset.dataset import InputExample
 from .batching import pad_batch_data
 import paddlehub as hub
 
@@ -100,7 +101,11 @@ class BaseReader(object):
             else:
                 tokens_b.pop()
 
-    def _convert_example_to_record(self, example, max_seq_length, tokenizer):
+    def _convert_example_to_record(self,
+                                   example,
+                                   max_seq_length,
+                                   tokenizer,
+                                   phase=None):
         """Converts a single `Example` into a single `Record`."""
 
         text_a = tokenization.convert_to_unicode(example.text_a)
@@ -171,11 +176,24 @@ class BaseReader(object):
             'Record',
             ['token_ids', 'text_type_ids', 'position_ids', 'label_id'])
 
-        record = Record(
-            token_ids=token_ids,
-            text_type_ids=text_type_ids,
-            position_ids=position_ids,
-            label_id=label_id)
+        if phase != "predict":
+            Record = namedtuple(
+                'Record',
+                ['token_ids', 'text_type_ids', 'position_ids', 'label_id'])
+
+            record = Record(
+                token_ids=token_ids,
+                text_type_ids=text_type_ids,
+                position_ids=position_ids,
+                label_id=label_id)
+        else:
+            Record = namedtuple('Record',
+                                ['token_ids', 'text_type_ids', 'position_ids'])
+            record = Record(
+                token_ids=token_ids,
+                text_type_ids=text_type_ids,
+                position_ids=position_ids)
+
         return record
 
     def _prepare_batch_data(self, examples, batch_size, phase=None):
@@ -185,7 +203,7 @@ class BaseReader(object):
             if phase == "train":
                 self.current_example = index
             record = self._convert_example_to_record(example, self.max_seq_len,
-                                                     self.tokenizer)
+                                                     self.tokenizer, phase)
             max_len = max(max_len, len(record.token_ids))
             if self.in_tokens:
                 to_append = (len(batch_records) + 1) * max_len <= batch_size
@@ -194,11 +212,11 @@ class BaseReader(object):
             if to_append:
                 batch_records.append(record)
             else:
-                yield self._pad_batch_records(batch_records)
+                yield self._pad_batch_records(batch_records, phase)
                 batch_records, max_len = [record], len(record.token_ids)
 
         if batch_records:
-            yield self._pad_batch_records(batch_records)
+            yield self._pad_batch_records(batch_records, phase)
 
     def get_num_examples(self, phase):
         """Get number of examples for train, dev or test."""
@@ -208,20 +226,51 @@ class BaseReader(object):
             )
         return self.num_examples[phase]
 
-    def data_generator(self, batch_size=1, phase='train', shuffle=True):
+    def data_generator(self,
+                       batch_size=1,
+                       phase='train',
+                       shuffle=True,
+                       data=None):
 
         if phase == 'train':
+            shuffle = True
             examples = self.get_train_examples()
             self.num_examples['train'] = len(examples)
         elif phase == 'val' or phase == 'dev':
+            shuffle = False
             examples = self.get_dev_examples()
             self.num_examples['dev'] = len(examples)
         elif phase == 'test':
+            shuffle = False
             examples = self.get_test_examples()
             self.num_examples['test'] = len(examples)
+        elif phase == 'predict':
+            shuffle = False
+            examples = []
+            seq_id = 0
+
+            for item in data:
+                # set label in order to run the program
+                label = "0"
+                if len(item) == 1:
+                    item_i = InputExample(
+                        guid=seq_id, text_a=item[0], label=label)
+                elif len(item) == 2:
+                    item_i = InputExample(
+                        guid=seq_id,
+                        text_a=item[0],
+                        text_b=item[1],
+                        label=label)
+                else:
+                    raise ValueError(
+                        "The length of input_text is out of handling, which must be 1 or 2!"
+                    )
+                examples.append(item_i)
+                seq_id += 1
         else:
             raise ValueError(
-                "Unknown phase, which should be in ['train', 'dev', 'test'].")
+                "Unknown phase, which should be in ['train', 'dev', 'test', 'predict']."
+            )
 
         def wrapper():
             if shuffle:
@@ -235,20 +284,11 @@ class BaseReader(object):
 
 
 class ClassifyReader(BaseReader):
-    def _pad_batch_records(self, batch_records):
+    def _pad_batch_records(self, batch_records, phase=None):
         batch_token_ids = [record.token_ids for record in batch_records]
         batch_text_type_ids = [record.text_type_ids for record in batch_records]
         batch_position_ids = [record.position_ids for record in batch_records]
-        batch_labels = [record.label_id for record in batch_records]
-        batch_labels = np.array(batch_labels).astype("int64").reshape([-1, 1])
-
-        # if batch_records[0].qid:
-        #     batch_qids = [record.qid for record in batch_records]
-        #     batch_qids = np.array(batch_qids).astype("int64").reshape([-1, 1])
-        # else:
-        #     batch_qids = np.array([]).astype("int64").reshape([-1, 1])
 
-        # padding
         padded_token_ids, input_mask = pad_batch_data(
             batch_token_ids,
             max_seq_len=self.max_seq_len,
@@ -263,20 +303,29 @@ class ClassifyReader(BaseReader):
             max_seq_len=self.max_seq_len,
             pad_idx=self.pad_id)
 
-        return_list = [
-            padded_token_ids, padded_position_ids, padded_text_type_ids,
-            input_mask, batch_labels
-        ]
+        if phase != "predict":
+            batch_labels = [record.label_id for record in batch_records]
+            batch_labels = np.array(batch_labels).astype("int64").reshape(
+                [-1, 1])
+
+            return_list = [
+                padded_token_ids, padded_position_ids, padded_text_type_ids,
+                input_mask, batch_labels
+            ]
+        else:
+            return_list = [
+                padded_token_ids, padded_position_ids, padded_text_type_ids,
+                input_mask
+            ]
 
         return return_list
 
 
 class SequenceLabelReader(BaseReader):
-    def _pad_batch_records(self, batch_records):
+    def _pad_batch_records(self, batch_records, phase=None):
         batch_token_ids = [record.token_ids for record in batch_records]
         batch_text_type_ids = [record.text_type_ids for record in batch_records]
         batch_position_ids = [record.position_ids for record in batch_records]
-        batch_label_ids = [record.label_ids for record in batch_records]
 
         # padding
         padded_token_ids, input_mask, batch_seq_lens = pad_batch_data(
@@ -293,65 +342,115 @@ class SequenceLabelReader(BaseReader):
             batch_position_ids,
             max_seq_len=self.max_seq_len,
             pad_idx=self.pad_id)
-        padded_label_ids = pad_batch_data(
-            batch_label_ids,
-            max_seq_len=self.max_seq_len,
-            pad_idx=len(self.label_map) - 1)
 
-        return_list = [
-            padded_token_ids, padded_position_ids, padded_text_type_ids,
-            input_mask, padded_label_ids, batch_seq_lens
-        ]
+        if phase != "predict":
+            batch_label_ids = [record.label_ids for record in batch_records]
+            padded_label_ids = pad_batch_data(
+                batch_label_ids,
+                max_seq_len=self.max_seq_len,
+                pad_idx=len(self.label_map) - 1)
+
+            return_list = [
+                padded_token_ids, padded_position_ids, padded_text_type_ids,
+                input_mask, padded_label_ids, batch_seq_lens
+            ]
+        else:
+            return_list = [
+                padded_token_ids, padded_position_ids, padded_text_type_ids,
+                input_mask, batch_seq_lens
+            ]
         return return_list
 
-    def _reseg_token_label(self, tokens, labels, tokenizer):
-        if len(tokens) != len(labels):
-            raise ValueError("The length of tokens must be same with labels")
-        ret_tokens = []
-        ret_labels = []
-        for token, label in zip(tokens, labels):
-            sub_token = tokenizer.tokenize(token)
-            if len(sub_token) == 0:
-                continue
-            ret_tokens.extend(sub_token)
-            ret_labels.append(label)
-            if len(sub_token) < 2:
-                continue
-            sub_label = label
-            if label.startswith("B-"):
-                sub_label = "I-" + label[2:]
-            ret_labels.extend([sub_label] * (len(sub_token) - 1))
-
-        if len(ret_tokens) != len(labels):
-            raise ValueError("The length of ret_tokens can't match with labels")
-        return ret_tokens, ret_labels
-
-    def _convert_example_to_record(self, example, max_seq_length, tokenizer):
-        tokens = tokenization.convert_to_unicode(example.text_a).split(u"")
-        labels = tokenization.convert_to_unicode(example.label).split(u"")
-        tokens, labels = self._reseg_token_label(tokens, labels, tokenizer)
+    def _reseg_token_label(self, tokens, tokenizer, phase, labels=None):
+        if phase != "predict":
+            if len(tokens) != len(labels):
+                raise ValueError(
+                    "The length of tokens must be same with labels")
+            ret_tokens = []
+            ret_labels = []
+            for token, label in zip(tokens, labels):
+                sub_token = tokenizer.tokenize(token)
+                if len(sub_token) == 0:
+                    continue
+                ret_tokens.extend(sub_token)
+                ret_labels.append(label)
+                if len(sub_token) < 2:
+                    continue
+                sub_label = label
+                if label.startswith("B-"):
+                    sub_label = "I-" + label[2:]
+                ret_labels.extend([sub_label] * (len(sub_token) - 1))
+
+            if len(ret_tokens) != len(labels):
+                raise ValueError(
+                    "The length of ret_tokens can't match with labels")
+            return ret_tokens, ret_labels
+        else:
+            ret_tokens = []
+            for token in tokens:
+                sub_token = tokenizer.tokenize(token)
+                if len(sub_token) == 0:
+                    continue
+                ret_tokens.extend(sub_token)
+                if len(sub_token) < 2:
+                    continue
+
+            return ret_tokens
+
+    def _convert_example_to_record(self,
+                                   example,
+                                   max_seq_length,
+                                   tokenizer,
+                                   phase=None):
 
-        if len(tokens) > max_seq_length - 2:
-            tokens = tokens[0:(max_seq_length - 2)]
-            labels = labels[0:(max_seq_length - 2)]
+        tokens = tokenization.convert_to_unicode(example.text_a).split(u"")
 
-        tokens = ["[CLS]"] + tokens + ["[SEP]"]
-        token_ids = tokenizer.convert_tokens_to_ids(tokens)
-        position_ids = list(range(len(token_ids)))
-        text_type_ids = [0] * len(token_ids)
-        no_entity_id = len(self.label_map) - 1
-        label_ids = [no_entity_id
-                     ] + [self.label_map[label]
-                          for label in labels] + [no_entity_id]
+        if phase != "predict":
+            labels = tokenization.convert_to_unicode(example.label).split(u"")
+            tokens, labels = self._reseg_token_label(
+                tokens=tokens, labels=labels, tokenizer=tokenizer, phase=phase)
+
+            if len(tokens) > max_seq_length - 2:
+                tokens = tokens[0:(max_seq_length - 2)]
+                labels = labels[0:(max_seq_length - 2)]
+
+            tokens = ["[CLS]"] + tokens + ["[SEP]"]
+            token_ids = tokenizer.convert_tokens_to_ids(tokens)
+            position_ids = list(range(len(token_ids)))
+            text_type_ids = [0] * len(token_ids)
+            no_entity_id = len(self.label_map) - 1
+            label_ids = [no_entity_id
+                         ] + [self.label_map[label]
+                              for label in labels] + [no_entity_id]
+
+            Record = namedtuple(
+                'Record',
+                ['token_ids', 'text_type_ids', 'position_ids', 'label_ids'])
+            record = Record(
+                token_ids=token_ids,
+                text_type_ids=text_type_ids,
+                position_ids=position_ids,
+                label_ids=label_ids)
+        else:
+            tokens = self._reseg_token_label(
+                tokens=tokens, tokenizer=tokenizer, phase=phase)
+
+            if len(tokens) > max_seq_length - 2:
+                tokens = tokens[0:(max_seq_length - 2)]
+
+            tokens = ["[CLS]"] + tokens + ["[SEP]"]
+            token_ids = tokenizer.convert_tokens_to_ids(tokens)
+            position_ids = list(range(len(token_ids)))
+            text_type_ids = [0] * len(token_ids)
+
+            Record = namedtuple('Record',
+                                ['token_ids', 'text_type_ids', 'position_ids'])
+            record = Record(
+                token_ids=token_ids,
+                text_type_ids=text_type_ids,
+                position_ids=position_ids,
+            )
 
-        Record = namedtuple(
-            'Record',
-            ['token_ids', 'text_type_ids', 'position_ids', 'label_ids'])
-        record = Record(
-            token_ids=token_ids,
-            text_type_ids=text_type_ids,
-            position_ids=position_ids,
-            label_ids=label_ids)
         return record