merge fit

callbacks.py

+# Copyright (c) 2020 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.
+
+import six
+import copy
+
+from progressbar import ProgressBar
+
+
+def config_callbacks(callbacks=None,
+                     model=None,
+                     batch_size=None,
+                     epochs=None,
+                     steps=None,
+                     log_freq=2,
+                     verbose=2,
+                     save_freq=1,
+                     metrics=None,
+                     mode='train'):
+    cbks = callbacks or []
+    cbks = cbks if isinstance(cbks, (list, tuple)) else [cbks]
+    if not any(isinstance(k, ProgBarLogger) for k in cbks) and verbose:
+        cbks = cbks + [ProgBarLogger(log_freq, verbose=verbose)]
+
+    if not any(isinstance(k, ModelCheckpoint) for k in cbks):
+        cbks = cbks + [ModelCheckpoint(save_freq)]
+
+    cbk_list = CallbackList(cbks)
+    cbk_list.set_model(model)
+    metrics = metrics or [] if mode != 'test' else []
+    params = {
+        'batch_size': batch_size,
+        'epochs': epochs,
+        'steps': steps,
+        'verbose': verbose,
+        'metrics': metrics,
+    }
+    cbk_list.set_params(params)
+    return cbk_list
+
+
+class CallbackList(object):
+    def __init__(self, callbacks=None):
+        # copy
+        self.callbacks = [c for c in callbacks]
+        self.params = {}
+        self.model = None
+
+    def append(self, callback):
+        self.callbacks.append(callback)
+
+    def __iter__(self):
+        return iter(self.callbacks)
+
+    def set_params(self, params):
+        for c in self.callbacks:
+            c.set_params(params)
+
+    def set_model(self, model):
+        for c in self.callbacks:
+            c.set_model(model)
+
+    def _call(self, name, *args):
+        for c in self.callbacks:
+            func = getattr(c, name)
+            func(*args)
+
+    def _check_mode(self, mode):
+        assert mode in ['train', 'eval', 'test'], \
+            'mode should be train, eval or test'
+
+    def on_begin(self, mode, logs=None):
+        self._check_mode(mode)
+        name = 'on_{}_begin'.format(mode)
+        self._call(name, logs)
+
+    def on_end(self, mode, logs=None):
+        self._check_mode(mode)
+        name = 'on_{}_end'.format(mode)
+        self._call(name, logs)
+
+    def on_epoch_begin(self, epoch=None, logs=None):
+        self._call('on_epoch_begin', epoch, logs)
+
+    def on_epoch_end(self, epoch=None, logs=None):
+        self._call('on_epoch_end', epoch, logs)
+
+    def on_batch_begin(self, mode, step=None, logs=None):
+        self._check_mode(mode)
+        name = 'on_{}_batch_begin'.format(mode)
+        self._call(name, step, logs)
+
+    def on_batch_end(self, mode, step=None, logs=None):
+        self._check_mode(mode)
+        name = 'on_{}_batch_end'.format(mode)
+        self._call(name, step, logs)
+
+
+class Callback(object):
+    def __init__(self):
+        self.model = None
+        self.params = {}
+
+    def set_params(self, params):
+        self.params = params
+
+    def set_model(self, model):
+        self.model = model
+
+    def on_train_begin(self, logs=None):
+        """
+        """
+
+    def on_train_end(self, logs=None):
+        """
+        """
+
+    def on_eval_begin(self, logs=None):
+        """
+        """
+
+    def on_eval_end(self, logs=None):
+        """
+        """
+
+    def on_test_begin(self, logs=None):
+        """
+        """
+
+    def on_test_end(self, logs=None):
+        """
+        """
+
+    def on_epoch_begin(self, epoch, logs=None):
+        """
+        """
+
+    def on_epoch_end(self, epoch, logs=None):
+        """
+        """
+
+    def on_train_batch_begin(self, step, logs=None):
+        """
+        """
+
+    def on_train_batch_end(self, step, logs=None):
+        """
+        """
+
+    def on_eval_batch_begin(self, step, logs=None):
+        """
+        """
+
+    def on_eval_batch_end(self, step, logs=None):
+        """
+        """
+
+    def on_eval_batch_begin(self, step, logs=None):
+        """
+        """
+
+    def on_eval_batch_end(self, step, logs=None):
+        """
+        """
+
+
+class ProgBarLogger(Callback):
+    def __init__(self, log_freq=1, verbose=2):
+        self.epochs = None
+        self.steps = None
+        self.progbar = None
+        self.verbose = verbose
+        self.log_freq = log_freq
+
+    def on_train_begin(self, logs=None):
+        self.epochs = self.params['epochs']
+        assert self.epochs
+        self.train_metrics = self.params['metrics']
+        assert self.train_metrics
+
+    def on_epoch_begin(self, epoch=None, logs=None):
+        self.steps = self.params['steps']
+        self.epoch = epoch
+        self.train_step = 0
+        if self.verbose and self.epochs:
+            print('Epoch %d/%d' % (epoch + 1, self.epochs))
+        self.train_progbar = ProgressBar(num=self.steps, verbose=self.verbose)
+
+    def _updates(self, logs, mode):
+        values = []
+        metrics = getattr(self, '%s_metrics' % (mode))
+        progbar = getattr(self, '%s_progbar' % (mode))
+        steps = getattr(self, '%s_step' % (mode))
+        for k in metrics:
+            if k in logs:
+                values.append((k, logs[k]))
+        progbar.update(steps, values)
+
+    def on_train_batch_end(self, step, logs=None):
+        logs = logs or {}
+        self.train_step = step
+
+        if self.train_step % self.log_freq == 0 and self.verbose:
+            # if steps is not None, last step will update in on_epoch_end
+            if self.steps and self.train_step < self.steps:
+                self._updates(logs, 'train')
+            else:
+                self._updates(logs, 'train')
+
+    def on_epoch_end(self, epoch, logs=None):
+        logs = logs or {}
+        if self.verbose:
+            self._updates(logs, 'train')
+
+    def on_eval_begin(self, logs=None):
+        self.eval_steps = logs.get('steps', None)
+        self.eval_metrics = logs.get('metrics_name', [])
+        self.eval_step = 0
+        self.evaled_samples = 0
+        self.eval_progbar = ProgressBar(
+            num=self.eval_steps, verbose=self.verbose)
+        print('Eval begin...')
+
+    def on_eval_batch_end(self, step, logs=None):
+        logs = logs or {}
+        self.eval_step = step
+        samples = logs.get('batch_size', 1)
+        self.evaled_samples += samples
+
+    def on_eval_end(self, logs=None):
+        logs = logs or {}
+        if self.verbose:
+            self._updates(logs, 'eval')
+            print('Eval samples: %d' % (self.evaled_samples))
+
+
+class ModelCheckpoint(Callback):
+    def __init__(self, save_freq=1, save_file='output'):
+        self.save_freq = save_freq
+        self.save_file = save_file
+
+    def on_epoch_begin(self, epoch=None, logs=None):
+        self.epoch = epoch
+
+    def on_epoch_end(self, epoch, logs=None):
+        if self.model and self.epoch % self.save_freq == 0:
+            path = '{}/{}'.format(self.save_file, epoch)
+            print('save checkpoint at {}'.format(path))
+            self.model.save(path)
+
+    def on_train_end(self, logs=None):
+        if self.model:
+            path = '{}/final'.format(self.save_file)
+            print('save checkpoint at {}'.format(path))
+            self.model.save(path)

image_classification/eval.py

-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-sys.path.append('../')
-
-import argparse
-import contextlib
-import time
-
-import numpy as np
-
-import paddle.fluid as fluid
-
-from model import CrossEntropy, Input
-from nets import ResNet
-from distributed import prepare_context, all_gather, Env, get_local_rank, get_nranks, DistributedBatchSampler
-from utils import ImageNetDataset
-from metrics import Accuracy
-from models.resnet import resnet50
-from paddle.fluid.io import BatchSampler, DataLoader
-
-def run(model, loader, mode='train'):
-    total_loss = 0
-    total_time = 0.0 #AverageMeter()
-    local_rank = get_local_rank()
-    start = time.time()
-    start_time = time.time()
-    for idx, batch in enumerate(loader()):
-        if not fluid.in_dygraph_mode():
-            batch = batch[0]
-        
-        losses, metrics = getattr(model, mode)(
-            batch[0], batch[1])
-
-        if idx > 1:  # skip first two steps
-            total_time += time.time() - start
-        total_loss += np.sum(losses)
-        if idx % 10 == 0 and local_rank == 0:
-            print("{:04d}: loss {:0.3f} top1: {:0.3f}% top5: {:0.3f}% time: {:0.3f} samples: {}".format(
-                idx, total_loss / (idx + 1), metrics[0][0] * 100, metrics[0][1] * 100, total_time / max(1, (idx - 1)), model._metrics[0].count[0]))
-        start = time.time()
-    eval_time = time.time() - start_time
-    for metric in model._metrics:
-        res = metric.accumulate()
-        if local_rank == 0:
-            print("[EVAL END]: top1: {:0.3f}%, top5: {:0.3f} total samples: {} total time: {:.3f}".format(res[0] * 100, res[1] * 100, model._metrics[0].count[0], eval_time))
-        metric.reset()
-
-
-def main():
-    @contextlib.contextmanager
-    def null_guard():
-        yield
-
-    place = fluid.CUDAPlace(fluid.dygraph.parallel.Env().dev_id) \
-        if get_nranks() > 1 else fluid.CUDAPlace(0)
-    guard = fluid.dygraph.guard(place) if FLAGS.dynamic else null_guard()
-    if get_nranks() > 1:
-        prepare_context(place)
-
-    if get_nranks() > 1 and not os.path.exists('resnet_checkpoints'):
-        os.mkdir('resnet_checkpoints')
-
-    with guard:
-        # model = ResNet()
-        model = resnet50(pretrained=True)
-        
-        inputs = [Input([None, 3, 224, 224], 'float32', name='image')]
-        labels = [Input([None, 1], 'int64', name='label')]
-
-        if fluid.in_dygraph_mode():
-            feed_list = None
-        else:
-            feed_list = [x.forward() for x in inputs + labels]
-            
-        val_dataset = ImageNetDataset(os.path.join(FLAGS.data, 'val'), mode='val')
-        if get_nranks() > 1:
-            distributed_sampler = DistributedBatchSampler(val_dataset, batch_size=FLAGS.batch_size)
-            val_loader = DataLoader(val_dataset, batch_sampler=distributed_sampler, places=place, 
-                                    feed_list=feed_list, num_workers=4, return_list=True)
-        else:
-            val_loader = DataLoader(val_dataset, batch_size=FLAGS.batch_size, places=place, 
-                                    feed_list=feed_list, num_workers=4, return_list=True)
-            
-        model.prepare(None, CrossEntropy(), Accuracy(topk=(1, 5)), inputs, labels, val_dataset)
-
-        # model.save('resnet_checkpoints/{:03d}'.format(000))
-        if FLAGS.resume is not None:
-            model.load(FLAGS.resume)
-
-        run(model, val_loader, mode='eval')
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser("Resnet Training on ImageNet")
-    parser.add_argument('data', metavar='DIR', help='path to dataset '
-                        '(should have subdirectories named "train" and "val"')
-    parser.add_argument(
-        "-d", "--dynamic", action='store_true', help="enable dygraph mode")
-    parser.add_argument(
-        "-e", "--epoch", default=90, type=int, help="number of epoch")
-    parser.add_argument(
-        '--lr', '--learning-rate', default=0.1, type=float, metavar='LR',
-        help='initial learning rate')
-    parser.add_argument(
-        "-b", "--batch_size", default=4, type=int, help="batch size")
-    parser.add_argument(
-        "-n", "--num_devices", default=1, type=int, help="number of devices")
-    parser.add_argument(
-        "-r", "--resume", default=None, type=str,
-        help="checkpoint path to resume")
-    FLAGS = parser.parse_args()
-    assert FLAGS.data, "error: must provide data path"
-    main()
\ No newline at end of file

image_classification/train.py

-# 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 division
-from __future__ import print_function
-
-import argparse
-import contextlib
-import os
-import sys
-sys.path.append('../')
-
-import time
-import math
-import numpy as np
-import paddle.fluid as fluid
-
-from model import CrossEntropy, Input
-from utils import AverageMeter, accuracy, ImageNetDataset
-from distributed import prepare_context, all_gather, Env, get_nranks, get_local_rank, DistributedBatchSampler
-from models import resnet50
-from metrics import Accuracy
-from paddle.fluid.io import BatchSampler, DataLoader
-
-
-def make_optimizer(parameter_list=None):
-    total_images = 1281167
-    base_lr = FLAGS.lr
-    momentum = 0.9
-    weight_decay = 1e-4
-    step_per_epoch = int(math.floor(float(total_images) / FLAGS.batch_size))
-    boundaries = [step_per_epoch * e for e in [30, 60, 90]]
-    values = [base_lr * (0.1**i) for i in range(len(boundaries) + 1)]
-    learning_rate = fluid.layers.piecewise_decay(
-        boundaries=boundaries, values=values)
-    learning_rate = fluid.layers.linear_lr_warmup(
-        learning_rate=learning_rate,
-        warmup_steps=5 * step_per_epoch,
-        start_lr=0.,
-        end_lr=base_lr)
-    optimizer = fluid.optimizer.Momentum(
-        learning_rate=learning_rate,
-        momentum=momentum,
-        regularization=fluid.regularizer.L2Decay(weight_decay),
-        parameter_list=parameter_list)
-    return optimizer
-
-
-def run(model, loader, mode='train'):
-    total_loss = 0
-    total_time = 0.0
-    local_rank = get_local_rank()
-    start = time.time()
-    start_time = time.time()
-    for idx, batch in enumerate(loader()):
-        if not fluid.in_dygraph_mode():
-            batch = batch[0]
-
-        losses, metrics = getattr(model, mode)(
-            batch[0], batch[1])
-
-        if idx > 1:  # skip first two steps
-            total_time += time.time() - start
-        total_loss += np.sum(losses)
-        if idx % 10 == 0 and local_rank == 0:
-            print("{:04d}: loss {:0.3f} top1: {:0.3f}% top5: {:0.3f}% time: {:0.3f} samples: {}".format(
-                idx, total_loss / (idx + 1), metrics[0][0] * 100, metrics[0][1] * 100, total_time / max(1, (idx - 1)), model._metrics[0].count[0]))
-        start = time.time()
-    eval_time = time.time() - start_time
-    for metric in model._metrics:
-        res = metric.accumulate()
-        if local_rank == 0 and mode == 'eval':
-            print("[EVAL END]: top1: {:0.3f}%, top5: {:0.3f} total samples: {} total time: {:.3f}".format(res[0] * 100, res[1] * 100, model._metrics[0].count[0], eval_time))
-        metric.reset()
-
-def main():
-    @contextlib.contextmanager
-    def null_guard():
-        yield
-
-    epoch = FLAGS.epoch
-    place = fluid.CUDAPlace(fluid.dygraph.parallel.Env().dev_id) \
-        if fluid.dygraph.parallel.Env().nranks > 1 else fluid.CUDAPlace(0)
-    guard = fluid.dygraph.guard(place) if FLAGS.dynamic else null_guard()
-    if fluid.dygraph.parallel.Env().nranks > 1:
-        prepare_context(place)
-
-    if not os.path.exists('resnet_checkpoints'):
-        os.mkdir('resnet_checkpoints')
-
-    with guard:
-        model = resnet50()
-        optim = make_optimizer(parameter_list=model.parameters())
-        
-        inputs = [Input([None, 3, 224, 224], 'float32', name='image')]
-        labels = [Input([None, 1], 'int64', name='label')]
-
-        if fluid.in_dygraph_mode():
-            feed_list = None
-        else:
-            feed_list = [x.forward() for x in inputs + labels]
-        
-        train_dataset = ImageNetDataset(os.path.join(FLAGS.data, 'val'), mode='train')
-        val_dataset = ImageNetDataset(os.path.join(FLAGS.data, 'val'), mode='val')
-        if get_nranks() > 1:
-            train_sampler = DistributedBatchSampler(train_dataset, batch_size=FLAGS.batch_size, shuffle=True)
-            train_loader = DataLoader(train_dataset, batch_sampler=train_sampler, places=place, 
-                                    feed_list=feed_list, num_workers=0, return_list=True)
-            val_sampler = DistributedBatchSampler(val_dataset, batch_size=FLAGS.batch_size)
-            val_loader = DataLoader(val_dataset, batch_sampler=val_sampler, places=place, 
-                                    feed_list=feed_list, num_workers=0, return_list=True)
-        else:
-            train_loader = DataLoader(train_dataset, batch_size=FLAGS.batch_size, places=place, 
-                                    feed_list=feed_list, num_workers=0, return_list=True)
-            val_loader = DataLoader(val_dataset, batch_size=FLAGS.batch_size, places=place, 
-                                    feed_list=feed_list, num_workers=0, return_list=True)
-
-        model.prepare(optim, CrossEntropy(), Accuracy(topk=(1, 5)), inputs, labels, val_dataset)
-        if FLAGS.resume is not None:
-            model.load(FLAGS.resume)
-
-        for e in range(epoch):
-            if get_local_rank() == 0:
-                print("======== train epoch {} ========".format(e))
-            run(model, train_loader)
-            model.save('resnet_checkpoints/{:02d}'.format(e))
-            if get_local_rank() == 0:
-                print("======== eval epoch {} ========".format(e))
-            run(model, val_loader, mode='eval')
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser("Resnet Training on ImageNet")
-    parser.add_argument('data', metavar='DIR', help='path to dataset '
-                        '(should have subdirectories named "train" and "val"')
-    parser.add_argument(
-        "-d", "--dynamic", action='store_true', help="enable dygraph mode")
-    parser.add_argument(
-        "-e", "--epoch", default=120, type=int, help="number of epoch")
-    parser.add_argument(
-        '--lr', '--learning-rate', default=0.1, type=float, metavar='LR',
-        help='initial learning rate')
-    parser.add_argument(
-        "-b", "--batch_size", default=256, type=int, help="batch size")
-    parser.add_argument(
-        "-n", "--num_devices", default=1, type=int, help="number of devices")
-    parser.add_argument(
-        "-r", "--resume", default=None, type=str,
-        help="checkpoint path to resume")
-    FLAGS = parser.parse_args()
-    assert FLAGS.data, "error: must provide data path"
-    main()

image_classification/utils.py

-import os
-import cv2
-import math
-import random
-import numpy as np
-
-class AverageMeter:
-    """Computes and stores the average and current value"""
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.val = 0
-        self.avg = 0
-        self.sum = 0
-        self.count = 0
-
-    def update(self, val, n=1):
-        self.val = val
-        self.sum += val * n
-        self.count += n
-        self.avg = self.sum / self.count
-        
-        
-def accuracy(pred, label, topk=(1, )):
-    maxk = max(topk)
-    pred = np.argsort(pred)[:, ::-1][:, :maxk]
-    correct = (pred == np.repeat(label, maxk, 1))
-
-    batch_size = label.shape[0]
-    res = []
-    for k in topk:
-        correct_k = correct[:, :k].sum()
-        res.append(100.0 * correct_k / batch_size)
-    return res
-
-
-def center_crop_resize(img):
-    h, w = img.shape[:2]
-    c = int(224 / 256 * min((h, w)))
-    i = (h + 1 - c) // 2
-    j = (w + 1 - c) // 2
-    img = img[i: i + c, j: j + c, :]
-    return cv2.resize(img, (224, 224), 0, 0, cv2.INTER_LINEAR)
-
-
-def random_crop_resize(img):
-    height, width = img.shape[:2]
-    area = height * width
-
-    for attempt in range(10):
-        target_area = random.uniform(0.08, 1.) * area
-        log_ratio = (math.log(3 / 4), math.log(4 / 3))
-        aspect_ratio = math.exp(random.uniform(*log_ratio))
-
-        w = int(round(math.sqrt(target_area * aspect_ratio)))
-        h = int(round(math.sqrt(target_area / aspect_ratio)))
-
-        if w <= width and h <= height:
-            i = random.randint(0, height - h)
-            j = random.randint(0, width - w)
-            img = img[i: i + h, j: j + w, :]
-            return cv2.resize(img, (224, 224), 0, 0, cv2.INTER_LINEAR)
-
-    return center_crop_resize(img)
-
-
-def random_flip(img):
-    return img[:, ::-1, :]
-
-
-def normalize_permute(img):
-    # transpose and convert to RGB from BGR
-    img = img.astype(np.float32).transpose((2, 0, 1))[::-1, ...]
-    mean = np.array([123.675, 116.28, 103.53], dtype=np.float32)
-    std = np.array([58.395, 57.120, 57.375], dtype=np.float32)
-    invstd = 1. / std
-    for v, m, s in zip(img, mean, invstd):
-        v.__isub__(m).__imul__(s)
-    return img
-
-
-def compose(functions):
-    def process(sample):
-        img, label = sample
-        for fn in functions:
-            img = fn(img)
-        return img, label
-    return process
-
-
-def image_folder(path):
-    valid_ext = ('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.webp')
-    classes = [d for d in os.listdir(path) if
-               os.path.isdir(os.path.join(path, d))]
-    classes.sort()
-    class_map = {cls: idx for idx, cls in enumerate(classes)}
-    samples = []
-    for dir in sorted(class_map.keys()):
-        d = os.path.join(path, dir)
-        for root, _, fnames in sorted(os.walk(d)):
-            for fname in sorted(fnames):
-                p = os.path.join(root, fname)
-                if os.path.splitext(p)[1].lower() in valid_ext:
-                    samples.append((p, [class_map[dir]]))
-    return samples
-
-
-class ImageNetDataset:
-    def __init__(self, path, mode='train'):
-        self.samples = image_folder(path)
-        self.mode = mode
-        if self.mode == 'train':
-            self.transform = compose([cv2.imread, random_crop_resize, random_flip,
-                            normalize_permute])
-        else:
-            self.transform = compose([cv2.imread, center_crop_resize, normalize_permute])
-
-    def __getitem__(self, idx):
-
-        return self.transform(self.samples[idx])
-
-    def __len__(self):
-        return len(self.samples)
\ No newline at end of file

metrics.py

@@ -44,21 +44,33 @@ class Metric(object):
         """
         Reset states and result
         """
-        raise NotImplementedError("function 'reset' not implemented in {}.".format(self.__class__.__name__))
+        raise NotImplementedError("function 'reset' not implemented in {}.".
+                                  format(self.__class__.__name__))
 
     @abc.abstractmethod
     def update(self, *args, **kwargs):
         """
         Update states for metric
         """
-        raise NotImplementedError("function 'update' not implemented in {}.".format(self.__class__.__name__))
+        raise NotImplementedError("function 'update' not implemented in {}.".
+                                  format(self.__class__.__name__))
 
     @abc.abstractmethod
     def accumulate(self):
         """
         Accumulates statistics, computes and returns the metric value
         """
-        raise NotImplementedError("function 'accumulate' not implemented in {}.".format(self.__class__.__name__))
+        raise NotImplementedError(
+            "function 'accumulate' not implemented in {}.".format(
+                self.__class__.__name__))
+
+    @abc.abstractmethod
+    def name(self):
+        """
+        Returns metric name
+        """
+        raise NotImplementedError("function 'name' not implemented in {}.".
+                                  format(self.__class__.__name__))
 
     def add_metric_op(self, pred, label):
         """
@@ -72,11 +84,12 @@ class Accuracy(Metric):
     Encapsulates accuracy metric logic
     """
 
-    def __init__(self, topk=(1, ), *args, **kwargs):
-       super(Accuracy, self).__init__(*args, **kwargs) 
-       self.topk = topk
-       self.maxk = max(topk)
-       self.reset()
+    def __init__(self, topk=(1, ), name=None, *args, **kwargs):
+        super(Accuracy, self).__init__(*args, **kwargs)
+        self.topk = topk
+        self.maxk = max(topk)
+        self._init_name(name)
+        self.reset()
 
     def add_metric_op(self, pred, label, *args, **kwargs):
         pred = fluid.layers.argsort(pred[0], descending=True)[1][:, :self.maxk]
@@ -103,3 +116,12 @@ class Accuracy(Metric):
             res.append(float(t) / c)
         return res
 
+    def _init_name(self, name):
+        name = name or 'acc'
+        if self.maxk != 1:
+            self._name = ['{}_top{}'.format(name, k) for k in self.topk]
+        else:
+            self._name = ['acc']
+
+    def name(self):
+        return self._name

model.py

@@ -18,6 +18,8 @@ import inspect
 import os
 import pickle
 import numpy as np
+from collections import Iterable
+from collections import OrderedDict
 
 from collections import OrderedDict
 from paddle import fluid
@@ -31,6 +33,7 @@ import paddle.fluid.incubate.fleet.base.role_maker as role_maker
 import distributed
 
 from metrics import Metric
+from callbacks import config_callbacks
 
 
 __all__ = ['Model', 'Loss', 'CrossEntropy', 'Input']
@@ -344,10 +347,10 @@ class StaticGraphAdapter(object):
             metric_list, metric_splits = flatten_list(endpoints['metric'])
             fetch_list = endpoints['loss'] + metric_list
             num_loss = len(endpoints['loss'])
-        rets = self._executor.run(
-            compiled_prog, feed=feed,
-            fetch_list=fetch_list,
-            return_numpy=False)
+        rets = self._executor.run(compiled_prog,
+                                  feed=feed,
+                                  fetch_list=fetch_list,
+                                  return_numpy=False)
         # LoDTensor cannot be fetch as numpy directly
         rets = [np.array(v) for v in rets]
         if self.mode == 'test':
@@ -434,7 +437,11 @@ class StaticGraphAdapter(object):
         self._input_vars[mode] = inputs
         
         self._progs[mode] = prog
-        self._endpoints[mode] = {"output": outputs, "loss": losses, "metric": metrics}
+        self._endpoints[mode] = {
+            "output": outputs,
+            "loss": losses,
+            "metric": metrics
+        }
 
 
     def _compile_and_initialize(self, prog, mode):
@@ -543,7 +550,10 @@ class DynamicGraphAdapter(object):
         if labels is not None:
             labels = [to_variable(l) for l in to_list(labels)]
         outputs = self.model.forward(*[to_variable(x) for x in inputs])
-        losses = self.model._loss_function(outputs, labels)
+        if self.model._loss_function:
+            losses = self.model._loss_function(outputs, labels)
+        else:
+            losses = []
         if self._nranks > 1:
             outputs = [distributed._all_gather(o, self._nranks) for o in to_list(outputs)]
             labels = [distributed._all_gather(l, self._nranks) for l in labels]
@@ -650,7 +660,6 @@ class Model(fluid.dygraph.Layer):
         self._labels = None
         self._loss_function = None
         self._loss_weights = None
-        self._loss = None
         self._optimizer = None
         self._device = None
         self._device_ids = None
@@ -678,6 +687,9 @@ class Model(fluid.dygraph.Layer):
     def load(self, *args, **kwargs):
         return self._adapter.load(*args, **kwargs)
 
+    def parameters(self, *args, **kwargs):
+        return self._adapter.parameters(*args, **kwargs)
+
     def prepare(self,
                 optimizer=None,
                 loss_function=None,
@@ -750,5 +762,102 @@ class Model(fluid.dygraph.Layer):
         if not in_dygraph_mode():
             self._adapter.prepare()
 
-    def parameters(self, *args, **kwargs):
-        return self._adapter.parameters(*args, **kwargs)
+    def fit(
+            self,
+            train_loader=None,
+            eval_loader=None,
+            epochs=1,
+            eval_freq=1,
+            log_freq=10,
+            save_freq=1,
+            verbose=2,
+            callbacks=None, ):
+        """
+        FIXME: add more comments and usage
+        Args:
+            train_loader (DataLoader): an iterable data loader is used for train.
+            eval_loader (DataLoader): an iterable data loader is used for
+                evaluation at the end of epoch. If None, will not do evaluation.
+            epochs (int): number of epochs to train the model.
+            eval_freq (int): evaluation frequency in epoch.
+            log_freq (int): frequency to print log during training.
+            save_freq (int): frequency to save checkpoint during training.
+            verbose (int): verbosity mode, should be 0, 1, or 2.
+                0 = silent, 1 = progress bar, 2 = one line per epoch.
+            callbacks (Callback|None): list of `Callback` instances to apply
+                during training.
+        """
+        do_eval = eval_loader is not None
+        metrics_name = self._metrics_name()
+        cbks = config_callbacks(
+            callbacks,
+            model=self,
+            epochs=epochs,
+            steps=None,
+            log_freq=log_freq,
+            save_freq=save_freq,
+            verbose=verbose,
+            metrics=self._metrics_name(), )
+
+        def _run_one_epoch(data_loader, callbacks, mode):
+            size = data_loader.size if hasattr(data_loader, 'size') else None
+            logs = {
+                'steps': size,
+                'metrics_name': metrics_name,
+            }
+            for step, data in enumerate(data_loader):
+                cbks.on_batch_begin(mode, step, logs)
+                if mode == 'train':
+                    outs = self.train(*data)
+                else:
+                    outs = self.eval(*data)
+
+                # losses
+                loss = outs[0] if self._metrics else outs
+                metrics = [[l[0] for l in loss]]
+
+                # metrics
+                for metric in self._metrics:
+                    res = metric.accumulate()
+                    metrics.extend(to_list(res))
+                assert len(metrics_name) == len(metrics)
+                for k, v in zip(metrics_name, metrics):
+                    logs[k] = v
+
+                logs['step'] = step
+                logs['batch_size'] = data[0].shape[0]
+
+                cbks.on_batch_end(mode, step, logs)
+            self._reset_metrics()
+            return logs
+
+        cbks.on_begin('train')
+        for epoch in range(epochs):
+            cbks.on_epoch_begin(epoch)
+            # FIXME: adapt to DataLoader
+            loader = train_loader
+            if not isinstance(train_loader, Iterable):
+                loader = train_loader()
+            logs = _run_one_epoch(loader, cbks, 'train')
+            cbks.on_epoch_end(epoch, logs)
+
+            if do_eval and epoch % eval_freq == 0:
+                cbks.on_begin('eval', logs)
+                # FIXME: adapt to DataLoader
+                loader = eval_loader
+                if not isinstance(eval_loader, Iterable):
+                    loader = eval_loader()
+                logs = _run_one_epoch(eval_loader(), cbks, 'eval')
+                cbks.on_end('eval', logs)
+
+        cbks.on_end('train', logs)
+
+    def _reset_metrics(self):
+        for metric in self._metrics:
+            metric.reset()
+
+    def _metrics_name(self):
+        metrics_name = ['loss']
+        for m in self._metrics:
+            metrics_name.extend(to_list(m.name()))
+        return metrics_name

models/__init__.py

-from .resnet import *
\ No newline at end of file

models/download.py

-#   Copyright (c) 2020 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 os.path as osp
-import shutil
-import requests
-import tqdm
-import hashlib
-import time
-
-import logging
-logger = logging.getLogger(__name__)
-
-__all__ = [
-    'get_weights_path'
-]
-
-WEIGHTS_HOME = osp.expanduser("~/.cache/paddle/hapi/weights")
-
-DOWNLOAD_RETRY_LIMIT = 3
-
-
-def get_weights_path(url):
-    """Get weights path from WEIGHT_HOME, if not exists,
-    download it from url.
-    """
-    path, _ = get_path(url, WEIGHTS_HOME)
-    return path
-
-
-
-def map_path(url, root_dir):
-    # parse path after download under root_dir
-    fname = osp.split(url)[-1]
-    fpath = fname
-    return osp.join(root_dir, fpath)
-
-
-def get_path(url, root_dir, md5sum=None, check_exist=True):
-    """ Download from given url to root_dir.
-    if file or directory specified by url is exists under
-    root_dir, return the path directly, otherwise download
-    from url and decompress it, return the path.
-
-    url (str): download url
-    root_dir (str): root dir for downloading, it should be
-                    WEIGHTS_HOME or DATASET_HOME
-    md5sum (str): md5 sum of download package
-    """
-    # parse path after download to decompress under root_dir
-    fullpath = map_path(url, root_dir)
-
-    exist_flag = False
-    if osp.exists(fullpath) and check_exist:
-        exist_flag = True
-        logger.info("Found {}".format(fullpath))
-    else:
-        if int(os.getenv("PADDLE_TRAINER_ID", "0")) == 0:
-            fullpath = _download(url, root_dir, md5sum)
-        else:
-            while not os.path.exists(fullpath):
-                time.sleep(1)
-    return fullpath, exist_flag
-
-
-def _download(url, path, md5sum=None):
-    """
-    Download from url, save to path.
-
-    url (str): download url
-    path (str): download to given path
-    """
-    if not osp.exists(path):
-        os.makedirs(path)
-
-    fname = osp.split(url)[-1]
-    fullname = osp.join(path, fname)
-    retry_cnt = 0
-
-    while not (osp.exists(fullname) and _md5check(fullname, md5sum)):
-        if retry_cnt < DOWNLOAD_RETRY_LIMIT:
-            retry_cnt += 1
-        else:
-            raise RuntimeError("Download from {} failed. "
-                               "Retry limit reached".format(url))
-
-        logger.info("Downloading {} from {}".format(fname, url))
-
-        req = requests.get(url, stream=True)
-        if req.status_code != 200:
-            raise RuntimeError("Downloading from {} failed with code "
-                               "{}!".format(url, req.status_code))
-
-        # For protecting download interupted, download to
-        # tmp_fullname firstly, move tmp_fullname to fullname
-        # after download finished
-        tmp_fullname = fullname + "_tmp"
-        total_size = req.headers.get('content-length')
-        with open(tmp_fullname, 'wb') as f:
-            if total_size:
-                for chunk in tqdm.tqdm(
-                        req.iter_content(chunk_size=1024),
-                        total=(int(total_size) + 1023) // 1024,
-                        unit='KB'):
-                    f.write(chunk)
-            else:
-                for chunk in req.iter_content(chunk_size=1024):
-                    if chunk:
-                        f.write(chunk)
-        shutil.move(tmp_fullname, fullname)
-
-    return fullname
-
-
-def _md5check(fullname, md5sum=None):
-    if md5sum is None:
-        return True
-
-    logger.info("File {} md5 checking...".format(fullname))
-    md5 = hashlib.md5()
-    with open(fullname, 'rb') as f:
-        for chunk in iter(lambda: f.read(4096), b""):
-            md5.update(chunk)
-    calc_md5sum = md5.hexdigest()
-
-    if calc_md5sum != md5sum:
-        logger.info("File {} md5 check failed, {}(calc) != "
-                    "{}(base)".format(fullname, calc_md5sum, md5sum))
-        return False
-    return True

models/resnet.py

-from __future__ import division
-from __future__ import print_function
-
-import math
-import paddle.fluid as fluid
-
-from paddle.fluid.layer_helper import LayerHelper
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
-from paddle.fluid.dygraph.container import Sequential
-
-from model import Model
-from .download import get_weights_path
-
-__all__ = ['ResNet', 'resnet50', 'resnet101', 'resnet152']
-
-
-model_urls = {
-    'resnet50': 'https://paddle-hapi.bj.bcebos.com/models/resnet50.pdparams'
-}
-
-
-class ConvBNLayer(fluid.dygraph.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 filter_size,
-                 stride=1,
-                 groups=1,
-                 act=None):
-        super(ConvBNLayer, self).__init__()
-
-        self._conv = Conv2D(
-            num_channels=num_channels,
-            num_filters=num_filters,
-            filter_size=filter_size,
-            stride=stride,
-            padding=(filter_size - 1) // 2,
-            groups=groups,
-            act=None,
-            bias_attr=False)
-
-        self._batch_norm = BatchNorm(num_filters, act=act)
-
-    def forward(self, inputs):
-        x = self._conv(inputs)
-        x = self._batch_norm(x)
-
-        return x
-
-
-class BasicBlock(fluid.dygraph.Layer):
-    expansion = 1
-
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 stride,
-                 shortcut=True):
-        super(BasicBlock, self).__init__()
-        if norm_layer is None:
-            norm_layer = nn.BatchNorm2d
-        if groups != 1 or base_width != 64:
-            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
-        if dilation > 1:
-            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
-        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
-        self.conv1 = conv3x3(inplanes, planes, stride)
-        self.bn1 = norm_layer(planes)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = conv3x3(planes, planes)
-        self.bn2 = norm_layer(planes)
-        self.downsample = downsample
-        self.stride = stride
-
-    def forward(self, x):
-        identity = x
-
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
-
-        out = self.conv2(out)
-        out = self.bn2(out)
-
-        if self.downsample is not None:
-            identity = self.downsample(x)
-
-        out += identity
-        out = self.relu(out)
-
-        return out
-
-
-class BottleneckBlock(fluid.dygraph.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 stride,
-                 shortcut=True):
-        super(BottleneckBlock, self).__init__()
-
-        self.conv0 = ConvBNLayer(
-            num_channels=num_channels,
-            num_filters=num_filters,
-            filter_size=1,
-            act='relu')
-        self.conv1 = ConvBNLayer(
-            num_channels=num_filters,
-            num_filters=num_filters,
-            filter_size=3,
-            stride=stride,
-            act='relu')
-        self.conv2 = ConvBNLayer(
-            num_channels=num_filters,
-            num_filters=num_filters * 4,
-            filter_size=1,
-            act=None)
-
-        if not shortcut:
-            self.short = ConvBNLayer(
-                num_channels=num_channels,
-                num_filters=num_filters * 4,
-                filter_size=1,
-                stride=stride)
-
-        self.shortcut = shortcut
-
-        self._num_channels_out = num_filters * 4
-
-    def forward(self, inputs):
-        x = self.conv0(inputs)
-        conv1 = self.conv1(x)
-        conv2 = self.conv2(conv1)
-
-        if self.shortcut:
-            short = inputs
-        else:
-            short = self.short(inputs)
-
-        x = fluid.layers.elementwise_add(x=short, y=conv2)
-
-        layer_helper = LayerHelper(self.full_name(), act='relu')
-        return layer_helper.append_activation(x)
-        # return fluid.layers.relu(x)
-
-
-class ResNet(Model):
-    def __init__(self, Block, depth=50, num_classes=1000):
-        super(ResNet, self).__init__()
-
-        layer_config = {
-            50: [3, 4, 6, 3],
-            101: [3, 4, 23, 3],
-            152: [3, 8, 36, 3],
-        }
-        assert depth in layer_config.keys(), \
-            "supported depth are {} but input layer is {}".format(
-                layer_config.keys(), depth)
-
-        layers = layer_config[depth]
-        num_in = [64, 256, 512, 1024]
-        num_out = [64, 128, 256, 512]
-
-        self.conv = ConvBNLayer(
-            num_channels=3,
-            num_filters=64,
-            filter_size=7,
-            stride=2,
-            act='relu')
-        self.pool = Pool2D(
-            pool_size=3,
-            pool_stride=2,
-            pool_padding=1,
-            pool_type='max')
-
-        self.layers = []
-        for idx, num_blocks in enumerate(layers):
-            blocks = []
-            shortcut = False
-            for b in range(num_blocks):
-                block = Block(
-                    num_channels=num_in[idx] if b == 0 else num_out[idx] * 4,
-                    num_filters=num_out[idx],
-                    stride=2 if b == 0 and idx != 0 else 1,
-                    shortcut=shortcut)
-                blocks.append(block)
-                shortcut = True
-            layer = self.add_sublayer(
-                "layer_{}".format(idx),
-                Sequential(*blocks))
-            self.layers.append(layer)
-
-        self.global_pool = Pool2D(
-            pool_size=7, pool_type='avg', global_pooling=True)
-
-        stdv = 1.0 / math.sqrt(2048 * 1.0)
-        self.fc_input_dim = num_out[-1] * 4 * 1 * 1
-        self.fc = Linear(self.fc_input_dim,
-                         num_classes,
-                         act='softmax',
-                         param_attr=fluid.param_attr.ParamAttr(
-                             initializer=fluid.initializer.Uniform(
-                                 -stdv, stdv)))
-
-    def forward(self, inputs):
-        x = self.conv(inputs)
-        x = self.pool(x)
-        for layer in self.layers:
-            x = layer(x)
-        x = self.global_pool(x)
-        x = fluid.layers.reshape(x, shape=[-1, self.fc_input_dim])
-        x = self.fc(x)
-        return x
-
-
-def _resnet(arch, Block, depth, pretrained):
-    model = ResNet(Block, depth)
-    if pretrained:
-        assert arch in model_urls, "{} model do not have a pretrained model now, you should set pretrained=False".format(arch)
-        weight_path = get_weights_path(model_urls[arch])
-        assert weight_path.endswith('.pdparams'), "suffix of weight must be .pdparams"
-        model.load(weight_path[:-9])
-    return model
-
-
-def resnet50(pretrained=False):
-    return _resnet('resnet50', BottleneckBlock, 50, pretrained)
-
-
-def resnet101(pretrained=False):
-    return _resnet('resnet101', BottleneckBlock, 101, pretrained)
-
-
-def resnet152(pretrained=False):
-    return _resnet('resnet152', BottleneckBlock, 152, pretrained)
\ No newline at end of file

progressbar.py

+import sys
+import time
+import numpy as np
+
+
+class ProgressBar(object):
+    """progress bar """
+
+    def __init__(self,
+                 num=None,
+                 width=30,
+                 verbose=1,
+                 start=True,
+                 file=sys.stdout):
+        self._num = num
+        if isinstance(num, int) and num <= 0:
+            raise TypeError('num should be None or integer (> 0)')
+        max_width = self._get_max_width()
+        self._width = width if width <= max_width else max_width
+        self._total_width = 0
+        self._verbose = verbose
+        self.file = file
+        self._values = {}
+        self._values_order = []
+        if start:
+            self._start = time.time()
+        self._last_update = 0
+
+        self._dynamic_display = (
+            (hasattr(self.file, 'isatty') and
+             self.file.isatty()) or 'ipykernel' in sys.modules or
+            'posix' in sys.modules or 'PYCHARM_HOSTED' in os.environ)
+
+    def _get_max_width(self):
+        if sys.version_info > (3, 3):
+            from shutil import get_terminal_size
+        else:
+            from backports.shutil_get_terminal_size import get_terminal_size
+        terminal_width, _ = get_terminal_size()
+        max_width = min(int(terminal_width * 0.6), terminal_width - 50)
+        return max_width
+
+    def start(self):
+        self.file.flush()
+        self._start = time.time()
+
+    def update(self, current_num, values=None):
+        now = time.time()
+
+        if current_num:
+            time_per_unit = (now - self._start) / current_num
+        else:
+            time_per_unit = 0
+
+        if time_per_unit >= 1 or time_per_unit == 0:
+            fps = ' - %.0fs/%s' % (time_per_unit, 'step')
+        elif time_per_unit >= 1e-3:
+            fps = ' - %.0fms/%s' % (time_per_unit * 1e3, 'step')
+        else:
+            fps = ' - %.0fus/%s' % (time_per_unit * 1e6, 'step')
+
+        info = ''
+        if self._verbose == 1:
+            prev_total_width = self._total_width
+
+            if self._dynamic_display:
+                sys.stdout.write('\b' * prev_total_width)
+                sys.stdout.write('\r')
+            else:
+                sys.stdout.write('\n')
+
+            if self._num is not None:
+                numdigits = int(np.log10(self._num)) + 1
+
+                bar_chars = ('step %' + str(numdigits) + 'd/%d [') % (
+                    current_num, self._num)
+                prog = float(current_num) / self._num
+                prog_width = int(self._width * prog)
+
+                if prog_width > 0:
+                    bar_chars += ('=' * (prog_width - 1))
+                    if current_num < self._num:
+                        bar_chars += '>'
+                    else:
+                        bar_chars += '='
+                bar_chars += ('.' * (self._width - prog_width))
+                bar_chars += ']'
+            else:
+                bar_chars = 'step %3d' % current_num
+
+            self._total_width = len(bar_chars)
+            sys.stdout.write(bar_chars)
+
+            for k, val in values:
+                info += ' - %s:' % k
+                val = val if isinstance(val, list) else [val]
+                for i, v in enumerate(val):
+                    if isinstance(v, (float, np.float32, np.float64)):
+                        if abs(v) > 1e-3:
+                            info += ' %.4f' % v
+                        else:
+                            info += ' %.4e' % v
+                    else:
+                        info += ' %s' % v
+
+            if self._num is not None and current_num < self._num:
+                eta = time_per_unit * (self._num - current_num)
+                if eta > 3600:
+                    eta_format = '%d:%02d:%02d' % (eta // 3600, (eta % 3600) //
+                                                   60, eta % 60)
+                elif eta > 60:
+                    eta_format = '%d:%02d' % (eta // 60, eta % 60)
+                else:
+                    eta_format = '%ds' % eta
+
+                info += ' - ETA: %s' % eta_format
+
+            info += fps
+            self._total_width += len(info)
+            if prev_total_width > self._total_width:
+                info += (' ' * (prev_total_width - self._total_width))
+
+            # newline for another epoch
+            if self._num is not None and current_num >= self._num:
+                info += '\n'
+            if self._num is None:
+                info += '\n'
+
+            sys.stdout.write(info)
+            sys.stdout.flush()
+            self._last_update = now
+        elif self._verbose == 2:
+            if self._num:
+                numdigits = int(np.log10(self._num)) + 1
+                count = ('step %' + str(numdigits) + 'd/%d') % (current_num,
+                                                                self._num)
+            else:
+                count = 'step %3d' % current_num
+            info = count + info
+
+            for k, val in values:
+                info += ' - %s:' % k
+                val = val if isinstance(val, list) else [val]
+                for v in val:
+                    if isinstance(v, (float, np.float32, np.float64)):
+                        if abs(v) > 1e-3:
+                            info += ' %.4f' % v
+                        else:
+                            info += ' %.4e' % v
+                    elif isinstance(v, np.ndarray) and \
+                         isinstance(v.size, 1) and \
+                         isinstance(v.dtype, (np.float32, np.float64)):
+                        if abs(v[0]) > 1e-3:
+                            info += ' %.4f' % v[0]
+                        else:
+                            info += ' %.4e' % v[0]
+                    else:
+                        info += ' %s' % v
+
+            info += fps
+            info += '\n'
+            sys.stdout.write(info)
+            sys.stdout.flush()

tests/test_callbacks.py

+# Copyright (c) 2020 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.
+
+import unittest
+import time
+import random
+
+from callbacks import config_callbacks
+
+
+class TestCallbacks(unittest.TestCase):
+    def test_callback(self):
+        epochs = 2
+        steps = 50
+        freq = 1
+        eval_steps = 20
+        cbks = config_callbacks(
+            batch_size=128,
+            epochs=epochs,
+            steps=steps,
+            verbose=2,
+            metrics=['loss', 'acc'], )
+        cbks.on_begin('train')
+
+        logs = {'loss': 50.341673, 'acc': 0.00256}
+        for epoch in range(epochs):
+            cbks.on_epoch_begin(epoch)
+            for step in range(steps):
+                cbks.on_batch_begin('train', step, logs)
+                logs['loss'] -= random.random() * 0.1
+                logs['acc'] += random.random() * 0.1
+                time.sleep(0.005)
+                cbks.on_batch_end('train', step, logs)
+            cbks.on_epoch_end(epoch, logs)
+
+            eval_logs = {'eval_loss': 20.341673, 'eval_acc': 0.256}
+            params = {
+                'eval_steps': eval_steps,
+                'eval_metrics': ['eval_loss', 'eval_acc'],
+                'log_freq': 10,
+            }
+            cbks.on_begin('eval', params)
+            for step in range(eval_steps):
+                cbks.on_batch_begin('eval', step, logs)
+                eval_logs['eval_loss'] -= random.random() * 0.1
+                eval_logs['eval_acc'] += random.random() * 0.1
+                eval_logs['batch_size'] = 2
+                time.sleep(0.005)
+                cbks.on_batch_end('eval', step, eval_logs)
+            cbks.on_end('eval', eval_logs)
+
+        cbks.on_end('train')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_model.py

+# Copyright (c) 2020 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 division
+from __future__ import print_function
+
+import unittest
+
+import os
+import numpy as np
+import contextlib
+
+import paddle
+from paddle import fluid
+from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
+from model import Model, CrossEntropy, Input, Loss
+from metrics import Accuracy
+from callbacks import ProgBarLogger
+
+
+class SimpleImgConvPool(fluid.dygraph.Layer):
+    def __init__(self,
+                 num_channels,
+                 num_filters,
+                 filter_size,
+                 pool_size,
+                 pool_stride,
+                 pool_padding=0,
+                 pool_type='max',
+                 global_pooling=False,
+                 conv_stride=1,
+                 conv_padding=0,
+                 conv_dilation=1,
+                 conv_groups=None,
+                 act=None,
+                 use_cudnn=False,
+                 param_attr=None,
+                 bias_attr=None):
+        super(SimpleImgConvPool, self).__init__('SimpleConv')
+
+        self._conv2d = Conv2D(
+            num_channels=num_channels,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=conv_stride,
+            padding=conv_padding,
+            dilation=conv_dilation,
+            groups=conv_groups,
+            param_attr=None,
+            bias_attr=None,
+            use_cudnn=use_cudnn)
+
+        self._pool2d = Pool2D(
+            pool_size=pool_size,
+            pool_type=pool_type,
+            pool_stride=pool_stride,
+            pool_padding=pool_padding,
+            global_pooling=global_pooling,
+            use_cudnn=use_cudnn)
+
+    def forward(self, inputs):
+        x = self._conv2d(inputs)
+        x = self._pool2d(x)
+        return x
+
+
+class MNIST(Model):
+    def __init__(self):
+        super(MNIST, self).__init__()
+        self._simple_img_conv_pool_1 = SimpleImgConvPool(
+            1, 20, 5, 2, 2, act="relu")
+
+        self._simple_img_conv_pool_2 = SimpleImgConvPool(
+            20, 50, 5, 2, 2, act="relu")
+
+        pool_2_shape = 50 * 4 * 4
+        SIZE = 10
+        scale = (2.0 / (pool_2_shape**2 * SIZE))**0.5
+        self._fc = Linear(
+            800,
+            10,
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.NormalInitializer(
+                    loc=0.0, scale=scale)),
+            act="softmax")
+
+    def forward(self, inputs):
+        x = self._simple_img_conv_pool_1(inputs)
+        x = self._simple_img_conv_pool_2(x)
+        x = fluid.layers.flatten(x, axis=1)
+        x = self._fc(x)
+        return x
+
+
+@contextlib.contextmanager
+def null_guard():
+    yield
+
+
+class MLP(Model):
+    def __init__(self):
+        super(MLP, self).__init__()
+        SIZE = 10
+        self._fc1 = Linear(784, 200, act="relu")
+        self._fc2 = Linear(200, 200, act="relu")
+        self._fc3 = Linear(200, 200, act="relu")
+        self._fc4 = Linear(200, 10, act="softmax")
+        self._fc5 = Linear(200, 10, act="softmax")
+
+    def forward(self, inputs):
+        x1 = self._fc1(inputs)
+        x2 = self._fc2(x1)
+        x3 = self._fc3(x2)
+        o1 = self._fc5(x3)
+        o2 = self._fc4(x2)
+        return o1, o2
+
+
+class MyCrossEntropy(Loss):
+    def __init__(self, average=True):
+        super(MyCrossEntropy, self).__init__()
+
+    def forward(self, outputs, labels):
+        loss1 = fluid.layers.cross_entropy(outputs[0], labels[0])
+        loss2 = fluid.layers.cross_entropy(outputs[1], labels[0])
+        return [loss1, loss2]
+
+
+class TestModel(unittest.TestCase):
+    def fit(self, dynamic, is_mlp=False):
+        im_shape = (-1, 784) if is_mlp else (-1, 1, 28, 28)
+        guard = fluid.dygraph.guard() if dynamic else null_guard()
+        batch_size = 128
+        train_loader = fluid.io.xmap_readers(
+            lambda b: [np.array([x[0] for x in b]).reshape(im_shape),
+                       np.array([x[1] for x in b]).reshape(-1, 1)],
+            paddle.batch(fluid.io.shuffle(paddle.dataset.mnist.train(), 6e4),
+                         batch_size=batch_size, drop_last=True), 1, 1)
+        val_loader = fluid.io.xmap_readers(
+            lambda b: [np.array([x[0] for x in b]).reshape(im_shape),
+                       np.array([x[1] for x in b]).reshape(-1, 1)],
+            paddle.batch(paddle.dataset.mnist.test(),
+                         batch_size=batch_size, drop_last=False), 1, 1)
+        with guard:
+            inputs = [Input(im_shape, 'float32', name='image')]
+            labels = [Input([None, 1], 'int64', name='label')]
+            model = MNIST() if not is_mlp else MLP()
+            optim = fluid.optimizer.Momentum(
+                learning_rate=0.01,
+                momentum=.9,
+                parameter_list=model.parameters())
+            loss = CrossEntropy() if not is_mlp else MyCrossEntropy()
+            model.prepare(optim, loss, Accuracy(), inputs, labels)
+            cbk = ProgBarLogger(50)
+            model.fit(train_loader, val_loader, epochs=2, callbacks=cbk)
+
+    def test_fit_static(self):
+        self.fit(False)
+
+    def test_fit_dygraph(self):
+        self.fit(True)
+
+    def test_fit_static_multi_loss(self):
+        self.fit(False, MyCrossEntropy())
+
+    def test_fit_dygraph_multi_loss(self):
+        self.fit(True, MyCrossEntropy())
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_progressbar.py

+# Copyright (c) 2020 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.
+
+import unittest
+import random
+import time
+
+from progressbar import ProgressBar
+
+
+class TestProgressBar(unittest.TestCase):
+    def prog_bar(self, num, epoch, width, verbose=1):
+        for epoch in range(epoch):
+            progbar = ProgressBar(num, verbose=verbose)
+            values = [
+                ['loss', 50.341673],
+                ['acc', 0.00256],
+            ]
+            for step in range(1, num + 1):
+                values[0][1] -= random.random() * 0.1
+                values[1][1] += random.random() * 0.1
+                if step % 10 == 0:
+                    progbar.update(step, values)
+                time.sleep(0.002)
+            progbar.update(step, values)
+
+    def test1(self):
+        self.prog_bar(50, 1, 30)
+
+    def test2(self):
+        self.prog_bar(50, 2, 30)
+
+    def test4(self):
+        self.prog_bar(50, 2, 30, verbose=2)
+
+
+if __name__ == '__main__':
+    unittest.main()