Merge pull request #53 from LielinJiang/loss-export

Add loss, save_inference_model and logger

examples/bert/bert_classifier.py

@@ -18,7 +18,8 @@ from hapi.metrics import Accuracy
 from hapi.configure import Config
 from hapi.text.bert import BertEncoder
 from paddle.fluid.dygraph import Linear, Layer
-from hapi.model import set_device, Model, SoftmaxWithCrossEntropy, Input
+from hapi.model import set_device, Model, Input
+from hapi.loss import SoftmaxWithCrossEntropy
 import hapi.text.tokenizer.tokenization as tokenization
 from hapi.text.bert import Optimizer, BertConfig, BertDataLoader, BertInputExample
 

examples/bert_leveldb/bert_classifier.py

@@ -18,7 +18,8 @@ from hapi.metrics import Accuracy
 from hapi.configure import Config
 from hapi.text.bert import BertEncoder
 from paddle.fluid.dygraph import Linear, Layer
-from hapi.model import set_device, Model, SoftmaxWithCrossEntropy, Input
+from hapi.model import set_device, Model, Input
+from hapi.loss import SoftmaxWithCrossEntropy
 import hapi.text.tokenizer.tokenization as tokenization
 from hapi.text.bert import Optimizer, BertConfig, BertDataLoader, BertInputExample
 

examples/bmn/modeling.py

@@ -17,8 +17,9 @@ from paddle.fluid import ParamAttr
 import numpy as np
 import math
 
-from hapi.model import Model, Loss
-from hapi.download import get_weights_path
+from hapi.model import Model
+from hapi.loss import Loss
+from hapi.download import get_weights_path_from_url
 
 __all__ = ["BMN", "BmnLoss", "bmn"]
 
@@ -459,7 +460,7 @@ def bmn(tscale,
     model = BMN(tscale, dscale, prop_boundary_ratio, num_sample,
                 num_sample_perbin)
     if pretrained:
-        weight_path = get_weights_path(*(pretrain_infos['bmn']))
+        weight_path = get_weights_path_from_url(*(pretrain_infos['bmn']))
         assert weight_path.endswith('.pdparams'), \
                 "suffix of weight must be .pdparams"
         model.load(weight_path)

examples/cyclegan/cyclegan.py

@@ -19,7 +19,8 @@ from __future__ import print_function
 import numpy as np
 
 import paddle.fluid as fluid
-from hapi.model import Model, Loss
+from hapi.model import Model
+from hapi.loss import Loss
 
 from layers import ConvBN, DeConvBN
 

examples/image_classification/imagenet_dataset.py

@@ -50,7 +50,7 @@ class ImageNetDataset(DatasetFolder):
     def __getitem__(self, idx):
         img_path, label = self.samples[idx]
         img = cv2.imread(img_path).astype(np.float32)
-        label = np.array([label])
+        label = np.array([label]).astype(np.int64)
         return self.transform(img), label
 
     def __len__(self):

examples/image_classification/main.py

@@ -27,7 +27,8 @@ import paddle.fluid as fluid
 from paddle.fluid.dygraph.parallel import ParallelEnv
 from paddle.io import BatchSampler, DataLoader
 
-from hapi.model import CrossEntropy, Input, set_device
+from hapi.model import Input, set_device
+from hapi.loss import CrossEntropy
 from hapi.distributed import DistributedBatchSampler
 from hapi.metrics import Accuracy
 import hapi.vision.models as models

examples/ocr/seq2seq_attn.py

@@ -20,7 +20,8 @@ import paddle.fluid.layers as layers
 from paddle.fluid.layers import BeamSearchDecoder
 
 from hapi.text import RNNCell, RNN, DynamicDecode
-from hapi.model import Model, Loss
+from hapi.model import Model
+from hapi.loss import Loss
 
 
 class ConvBNPool(fluid.dygraph.Layer):

examples/sequence_tagging/train.py

@@ -29,7 +29,8 @@ work_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.append(os.path.join(work_dir, "../"))
 
 from hapi.metrics import Metric
-from hapi.model import Model, Input, Loss, set_device
+from hapi.model import Model, Input, set_device
+from hapi.loss import Loss
 from hapi.text.text import SequenceTagging
 
 from utils.check import check_gpu, check_version

examples/tsm/main.py

@@ -22,7 +22,8 @@ import numpy as np
 from paddle import fluid
 from paddle.fluid.dygraph.parallel import ParallelEnv
 
-from hapi.model import Model, CrossEntropy, Input, set_device
+from hapi.model import Model, Input, set_device
+from hapi.loss import CrossEntropy
 from hapi.metrics import Accuracy
 from hapi.vision.transforms import Compose
 
@@ -34,11 +35,10 @@ from transforms import *
 
 def make_optimizer(step_per_epoch, parameter_list=None):
     boundaries = [e * step_per_epoch for e in [40, 60]]
-    values = [FLAGS.lr * (0.1 ** i) for i in range(len(boundaries) + 1)]
+    values = [FLAGS.lr * (0.1**i) for i in range(len(boundaries) + 1)]
 
     learning_rate = fluid.layers.piecewise_decay(
-        boundaries=boundaries,
-        values=values)
+        boundaries=boundaries, values=values)
     optimizer = fluid.optimizer.Momentum(
         learning_rate=learning_rate,
         regularization=fluid.regularizer.L2Decay(1e-4),
@@ -52,29 +52,27 @@ def main():
     device = set_device(FLAGS.device)
     fluid.enable_dygraph(device) if FLAGS.dynamic else None
 
-    train_transform = Compose([GroupScale(),
-                               GroupMultiScaleCrop(),
-                               GroupRandomCrop(),
-                               GroupRandomFlip(),
-                               NormalizeImage()])
+    train_transform = Compose([
+        GroupScale(), GroupMultiScaleCrop(), GroupRandomCrop(),
+        GroupRandomFlip(), NormalizeImage()
+    ])
     train_dataset = KineticsDataset(
-            file_list=os.path.join(FLAGS.data, 'train_10.list'),
-            pickle_dir=os.path.join(FLAGS.data, 'train_10'),
-            label_list=os.path.join(FLAGS.data, 'label_list'),
-            transform=train_transform)
-    val_transform = Compose([GroupScale(),
-                             GroupCenterCrop(),
-                             NormalizeImage()])
+        file_list=os.path.join(FLAGS.data, 'train_10.list'),
+        pickle_dir=os.path.join(FLAGS.data, 'train_10'),
+        label_list=os.path.join(FLAGS.data, 'label_list'),
+        transform=train_transform)
+    val_transform = Compose(
+        [GroupScale(), GroupCenterCrop(), NormalizeImage()])
     val_dataset = KineticsDataset(
-            file_list=os.path.join(FLAGS.data, 'val_10.list'),
-            pickle_dir=os.path.join(FLAGS.data, 'val_10'),
-            label_list=os.path.join(FLAGS.data, 'label_list'),
-            mode='val',
-            transform=val_transform)
+        file_list=os.path.join(FLAGS.data, 'val_10.list'),
+        pickle_dir=os.path.join(FLAGS.data, 'val_10'),
+        label_list=os.path.join(FLAGS.data, 'label_list'),
+        mode='val',
+        transform=val_transform)
 
     pretrained = FLAGS.eval_only and FLAGS.weights is None
-    model = tsm_resnet50(num_classes=train_dataset.num_classes,
-                         pretrained=pretrained)
+    model = tsm_resnet50(
+        num_classes=train_dataset.num_classes, pretrained=pretrained)
 
     step_per_epoch = int(len(train_dataset) / FLAGS.batch_size \
                          / ParallelEnv().nranks)
@@ -117,7 +115,9 @@ def main():
 if __name__ == '__main__':
     parser = argparse.ArgumentParser("CNN training on TSM")
     parser.add_argument(
-        "--data", type=str, default='dataset/kinetics',
+        "--data",
+        type=str,
+        default='dataset/kinetics',
         help="path to dataset root directory")
     parser.add_argument(
         "--device", type=str, default='gpu', help="device to use, gpu or cpu")

examples/tsm/modeling.py

@@ -18,7 +18,7 @@ from paddle.fluid.layer_helper import LayerHelper
 from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
 
 from hapi.model import Model
-from hapi.download import get_weights_path
+from hapi.download import get_weights_path_from_url
 
 __all__ = ["TSM_ResNet", "tsm_resnet50"]
 
@@ -122,6 +122,7 @@ class TSM_ResNet(Model):
         seg_num (int): segment number of each video sample. Default 8.
         num_classes (int): video class number. Default 400.
     """
+
     def __init__(self, num_layers=50, seg_num=8, num_classes=400):
         super(TSM_ResNet, self).__init__()
 
@@ -136,7 +137,11 @@ class TSM_ResNet(Model):
         num_filters = [64, 128, 256, 512]
 
         self.conv = ConvBNLayer(
-            num_channels=3, num_filters=64, filter_size=7, stride=2, act='relu')
+            num_channels=3,
+            num_filters=64,
+            filter_size=7,
+            stride=2,
+            act='relu')
         self.pool2d_max = Pool2D(
             pool_size=3, pool_stride=2, pool_padding=1, pool_type='max')
 
@@ -193,7 +198,7 @@ def _tsm_resnet(num_layers, seg_num=8, num_classes=400, pretrained=True):
         assert num_layers in pretrain_infos.keys(), \
                 "TSM-ResNet{} do not have pretrained weights now, " \
                 "pretrained should be set as False".format(num_layers)
-        weight_path = get_weights_path(*(pretrain_infos[num_layers]))
+        weight_path = get_weights_path_from_url(*(pretrain_infos[num_layers]))
         assert weight_path.endswith('.pdparams'), \
                 "suffix of weight must be .pdparams"
         model.load(weight_path)

examples/yolov3/modeling.py

@@ -20,8 +20,9 @@ from paddle.fluid.dygraph.nn import Conv2D, BatchNorm
 from paddle.fluid.param_attr import ParamAttr
 from paddle.fluid.regularizer import L2Decay
 
-from hapi.model import Model, Loss
-from hapi.download import get_weights_path
+from hapi.model import Model
+from hapi.loss import Loss
+from hapi.download import get_weights_path_from_url
 from hapi.vision.models import darknet53
 
 __all__ = ['YoloLoss', 'YOLOv3', 'yolov3_darknet53']
@@ -315,7 +316,7 @@ def _yolov3_darknet(num_layers=53,
         assert num_layers in pretrain_infos.keys(), \
                 "YOLOv3-DarkNet{} do not have pretrained weights now, " \
                 "pretrained should be set as False".format(num_layers)
-        weight_path = get_weights_path(*(pretrain_infos[num_layers]))
+        weight_path = get_weights_path_from_url(*(pretrain_infos[num_layers]))
         assert weight_path.endswith('.pdparams'), \
                 "suffix of weight must be .pdparams"
         model.load(weight_path)

hapi/__init__.py

@@ -11,7 +11,7 @@
 # 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 hapi import logger
 from hapi.configure import Config
 from hapi import callbacks
 from hapi import datasets
@@ -22,16 +22,11 @@ from hapi import model
 from hapi import progressbar
 from hapi import text
 from hapi import vision
+from hapi import loss
+
+logger.setup_logger()
 
 __all__ = [
-    'Config',
-    'callbacks',
-    'datasets',
-    'distributed',
-    'download',
-    'metrics',
-    'model',
-    'progressbar',
-    'text',
-    'vision',
+    'Config', 'callbacks', 'datasets', 'distributed', 'download', 'metrics',
+    'model', 'progressbar', 'text', 'vision', 'loss'
 ]

hapi/datasets/folder.py

@@ -150,7 +150,7 @@ class DatasetFolder(Dataset):
         path, target = self.samples[index]
         sample = self.loader(path)
         if self.transform is not None:
-            sample, target = self.transform(sample)
+            sample = self.transform(sample)
 
         return sample, target
 

hapi/download.py

@@ -29,7 +29,7 @@ from paddle.fluid.dygraph.parallel import ParallelEnv
 import logging
 logger = logging.getLogger(__name__)
 
-__all__ = ['get_weights_path', 'is_url']
+__all__ = ['get_weights_path_from_url', 'is_url']
 
 WEIGHTS_HOME = osp.expanduser("~/.cache/paddle/hapi/weights")
 
@@ -45,48 +45,56 @@ def is_url(path):
     return path.startswith('http://') or path.startswith('https://')
 
 
-def get_weights_path(url, md5sum=None):
+def get_weights_path_from_url(url, md5sum=None):
     """Get weights path from WEIGHT_HOME, if not exists,
     download it from url.
+
+    Args:
+        url (str): download url
+        md5sum (str): md5 sum of download package
+    
+    Returns:
+        str: a local path to save downloaded weights.
     """
-    path, _ = get_path(url, WEIGHTS_HOME, md5sum)
+    path = get_path_from_url(url, WEIGHTS_HOME, md5sum)
     return path
 
 
-def map_path(url, root_dir):
+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):
+def get_path_from_url(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
+    Args:
+        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
+    
+    Returns:
+        str: a local path to save downloaded models & weights & datasets.
     """
     assert is_url(url), "downloading from {} not a url".format(url)
     # parse path after download to decompress under root_dir
-    fullpath = map_path(url, root_dir)
+    fullpath = _map_path(url, root_dir)
 
-    exist_flag = False
     if osp.exists(fullpath) and check_exist and _md5check(fullpath, md5sum):
-        exist_flag = True
-        if ParallelEnv().local_rank == 0:
-            logger.info("Found {}".format(fullpath))
+        logger.info("Found {}".format(fullpath))
     else:
         if ParallelEnv().local_rank == 0:
             fullpath = _download(url, root_dir, md5sum)
         else:
             while not os.path.exists(fullpath):
                 time.sleep(1)
-    return fullpath, exist_flag
+    return fullpath
 
 
 def _download(url, path, md5sum=None):
@@ -109,8 +117,8 @@ def _download(url, path, md5sum=None):
         else:
             raise RuntimeError("Download from {} failed. "
                                "Retry limit reached".format(url))
-        if ParallelEnv().local_rank == 0:
-            logger.info("Downloading {} from {}".format(fname, url))
+
+        logger.info("Downloading {} from {}".format(fname, url))
 
         req = requests.get(url, stream=True)
         if req.status_code != 200:
@@ -141,8 +149,8 @@ def _download(url, path, md5sum=None):
 def _md5check(fullname, md5sum=None):
     if md5sum is None:
         return True
-    if ParallelEnv().local_rank == 0:
-        logger.info("File {} md5 checking...".format(fullname))
+
+    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""):
@@ -150,8 +158,7 @@ def _md5check(fullname, md5sum=None):
     calc_md5sum = md5.hexdigest()
 
     if calc_md5sum != md5sum:
-        if ParallelEnv().local_rank == 0:
-            logger.info("File {} md5 check failed, {}(calc) != "
-                        "{}(base)".format(fullname, calc_md5sum, md5sum))
+        logger.info("File {} md5 check failed, {}(calc) != "
+                    "{}(base)".format(fullname, calc_md5sum, md5sum))
         return False
     return True

hapi/logger.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 os
+import sys
+import logging
+
+from paddle.fluid.dygraph.parallel import ParallelEnv
+
+
+def setup_logger(output=None, name="hapi", log_level=logging.INFO):
+    """
+    Initialize logger of hapi and set its verbosity level to "INFO".
+
+    Args:
+        output (str): a file name or a directory to save log. If None, will not save log file.
+            If ends with ".txt" or ".log", assumed to be a file name.
+            Otherwise, logs will be saved to `output/log.txt`.
+        name (str): the root module name of this logger. Default: 'hapi'.
+        log_level (enum): log level. eg.'INFO', 'DEBUG', 'ERROR'. Default: logging.INFO.
+    Returns:
+        logging.Logger: a logger
+    """
+    logger = logging.getLogger(name)
+    logger.propagate = False
+    logger.setLevel(log_level)
+
+    # stdout logging: only local rank==0
+    local_rank = ParallelEnv().local_rank
+    if local_rank == 0:
+        ch = logging.StreamHandler(stream=sys.stdout)
+        ch.setLevel(log_level)
+
+        format_str = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        ch.setFormatter(logging.Formatter(format_str))
+        logger.addHandler(ch)
+
+    # file logging if output is not None: all workers
+    if output is not None:
+        if output.endswith(".txt") or output.endswith(".log"):
+            filename = output
+        else:
+            filename = os.path.join(output, "log.txt")
+        if local_rank > 0:
+            filename = filename + ".rank{}".format(local_rank)
+
+        if not os.path.exists(os.path.dirname(filename)):
+            os.makedirs(os.path.dirname(filename))
+
+        fh = logging.StreamHandler(filename)
+        fh.setLevel(log_level)
+        fh.setFormatter(logging.Formatter(format_str))
+        logger.addHandler(fh)
+
+    return logger

hapi/loss.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
+
+import os
+
+from paddle import fluid
+from paddle.fluid.framework import in_dygraph_mode, Variable
+from paddle.fluid.dygraph.base import to_variable
+
+from hapi.utils import to_list
+
+__all__ = ['Loss', 'CrossEntropy', 'SoftmaxWithCrossEntropy']
+
+
+class Loss(object):
+    """
+    Base class for loss, encapsulates loss logic and APIs
+
+    Usage:
+    custom_loss = CustomLoss()
+    loss = custom_loss(inputs, labels)
+    """
+
+    def __init__(self, average=True):
+        super(Loss, self).__init__()
+        self.average = average
+
+    def forward(self, outputs, labels):
+        raise NotImplementedError()
+
+    def __call__(self, outputs, labels=None):
+        labels = to_list(labels)
+        if in_dygraph_mode() and labels:
+            labels = [to_variable(l) for l in labels]
+        losses = to_list(self.forward(to_list(outputs), labels))
+        if self.average:
+            losses = [fluid.layers.reduce_mean(l) for l in losses]
+        else:
+            losses = [fluid.layers.reduce_sum(l) for l in losses]
+        return losses
+
+
+class CrossEntropy(Loss):
+    """
+    Args:
+        input (list[Variable]): Input tensor, the data type is float32,
+            float64, int32, int64.
+        label (list[Variable]): Label tensor, the data type is float32,
+            float64, int32, int64.
+        average (bool, optional): Indicate whether to average the loss, Default: True.
+    Returns:
+        list[Variable]: The tensor variable storing the cross_entropy_loss of inputs and labels.
+    """
+
+    def __init__(self, average=True):
+        super(CrossEntropy, self).__init__()
+
+    def forward(self, outputs, labels):
+        return [
+            fluid.layers.cross_entropy(o, l) for o, l in zip(outputs, labels)
+        ]
+
+
+class SoftmaxWithCrossEntropy(Loss):
+    """
+    this op combined softmax and cross entropy.
+    Args:
+        input (list[Variable]): Input tensor, the data type is float32,
+            float64, int32, int64.
+        label (list[Variable]): Label tensor, the data type is float32,
+            float64, int32, int64.
+        average (bool, optional): Indicate whether to average the loss, Default: True.
+    Returns:
+        list[Variable]: The tensor variable storing the cross_entropy_loss of inputs and labels.
+    """
+
+    def __init__(self, average=True):
+        super(SoftmaxWithCrossEntropy, self).__init__()
+
+    def forward(self, outputs, labels):
+        return [
+            fluid.layers.softmax_with_cross_entropy(
+                o, l, return_softmax=False) for o, l in zip(outputs, labels)
+        ]

hapi/model.py

@@ -34,13 +34,16 @@ from paddle.fluid.incubate.fleet.collective import fleet, DistributedStrategy
 from paddle.fluid.incubate.fleet.base import role_maker
 from paddle.io import DataLoader, Dataset
 
+from hapi.loss import Loss
 from hapi.distributed import DistributedBatchSampler, _all_gather, prepare_distributed_context, _parallel_context_initialized
 from hapi.metrics import Metric
 from hapi.callbacks import config_callbacks
+from hapi.utils import to_list, to_numpy, flatten_list, restore_flatten_list
 
 __all__ = [
-    'Model', 'Loss', 'CrossEntropy', 'Input', 'set_device',
-    'SoftmaxWithCrossEntropy'
+    'Model',
+    'Input',
+    'set_device',
 ]
 
 
@@ -63,49 +66,6 @@ def set_device(device):
     return place
 
 
-def to_list(value):
-    if value is None:
-        return value
-    if isinstance(value, (list, tuple)):
-        return list(value)
-    return [value]
-
-
-def to_numpy(var):
-    assert isinstance(var, (Variable, fluid.core.VarBase)), "not a variable"
-    if isinstance(var, fluid.core.VarBase):
-        return var.numpy()
-    t = global_scope().find_var(var.name).get_tensor()
-    return np.array(t)
-
-
-def flatten_list(l):
-    assert isinstance(l, list), "not a list"
-    outl = []
-    splits = []
-    for sl in l:
-        assert isinstance(sl, list), "sub content not a list"
-        splits.append(len(sl))
-        outl += sl
-    return outl, splits
-
-
-def restore_flatten_list(l, splits):
-    outl = []
-    for split in splits:
-        assert len(l) >= split, "list length invalid"
-        sl, l = l[:split], l[split:]
-        outl.append(sl)
-    return outl
-
-
-def extract_args(func):
-    if hasattr(inspect, 'getfullargspec'):
-        return inspect.getfullargspec(func)[0]
-    else:
-        return inspect.getargspec(func)[0]
-
-
 class Input(fluid.dygraph.Layer):
     def __init__(self, shape=None, dtype=None, name=None):
         super(Input, self).__init__()
@@ -117,47 +77,6 @@ class Input(fluid.dygraph.Layer):
         return fluid.data(self.name, shape=self.shape, dtype=self.dtype)
 
 
-class Loss(object):
-    def __init__(self, average=True):
-        super(Loss, self).__init__()
-        self.average = average
-
-    def forward(self, outputs, labels):
-        raise NotImplementedError()
-
-    def __call__(self, outputs, labels=None):
-        labels = to_list(labels)
-        if in_dygraph_mode() and labels:
-            labels = [to_variable(l) for l in labels]
-        losses = to_list(self.forward(to_list(outputs), labels))
-        if self.average:
-            losses = [fluid.layers.reduce_mean(l) for l in losses]
-        else:
-            losses = [fluid.layers.reduce_sum(l) for l in losses]
-        return losses
-
-
-class CrossEntropy(Loss):
-    def __init__(self, average=True):
-        super(CrossEntropy, self).__init__()
-
-    def forward(self, outputs, labels):
-        return [
-            fluid.layers.cross_entropy(o, l) for o, l in zip(outputs, labels)
-        ]
-
-
-class SoftmaxWithCrossEntropy(Loss):
-    def __init__(self, average=True):
-        super(SoftmaxWithCrossEntropy, self).__init__()
-
-    def forward(self, outputs, labels):
-        return [
-            fluid.layers.softmax_with_cross_entropy(
-                o, l, return_softmax=False) for o, l in zip(outputs, labels)
-        ]
-
-
 class StaticGraphAdapter(object):
     def __init__(self, model):
         super(StaticGraphAdapter, self).__init__()
@@ -576,15 +495,14 @@ class DynamicGraphAdapter(object):
         if labels is not None:
             labels = [to_variable(l) for l in to_list(labels)]
         if self._nranks > 1:
-            outputs = self.ddp_model.forward(
-                * [to_variable(x) for x in inputs])
+            outputs = self.ddp_model.forward(*[to_variable(x) for x in inputs])
             losses = self.model._loss_function(outputs, labels)
             final_loss = fluid.layers.sum(losses)
             final_loss = self.ddp_model.scale_loss(final_loss)
             final_loss.backward()
             self.ddp_model.apply_collective_grads()
         else:
-            outputs = self.model.forward(* [to_variable(x) for x in inputs])
+            outputs = self.model.forward(*[to_variable(x) for x in inputs])
             losses = self.model._loss_function(outputs, labels)
             final_loss = fluid.layers.sum(losses)
             final_loss.backward()
@@ -593,9 +511,9 @@ class DynamicGraphAdapter(object):
         self.model.clear_gradients()
         metrics = []
         for metric in self.model._metrics:
-            metric_outs = metric.add_metric_op(*(to_list(outputs) + to_list(
-                labels)))
-            m = metric.update(* [to_numpy(m) for m in to_list(metric_outs)])
+            metric_outs = metric.add_metric_op(*(
+                to_list(outputs) + to_list(labels)))
+            m = metric.update(*[to_numpy(m) for m in to_list(metric_outs)])
             metrics.append(m)
 
         return ([to_numpy(l) for l in losses], metrics) \
@@ -607,7 +525,7 @@ class DynamicGraphAdapter(object):
         inputs = to_list(inputs)
         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])
+        outputs = self.model.forward(*[to_variable(x) for x in inputs])
         if self.model._loss_function:
             losses = self.model._loss_function(outputs, labels)
         else:
@@ -633,9 +551,9 @@ class DynamicGraphAdapter(object):
                     self._merge_count[self.mode + '_total'] += samples
                     self._merge_count[self.mode + '_batch'] = samples
 
-            metric_outs = metric.add_metric_op(*(to_list(outputs) + to_list(
-                labels)))
-            m = metric.update(* [to_numpy(m) for m in to_list(metric_outs)])
+            metric_outs = metric.add_metric_op(*(
+                to_list(outputs) + to_list(labels)))
+            m = metric.update(*[to_numpy(m) for m in to_list(metric_outs)])
             metrics.append(m)
 
         # To be consistent with static graph
@@ -1216,6 +1134,51 @@ class Model(fluid.dygraph.Layer):
 
         return outputs
 
+    def save_inference_model(self,
+                             save_dir,
+                             model_filename=None,
+                             params_filename=None,
+                             program_only=False):
+        """
+        Save inference model must in static mode.
+
+        Args:
+            dirname(str): The directory path to save the inference model.
+            model_filename(str|None): The name of file to save the inference program
+                                        itself. If is set None, a default filename
+                                        :code:`__model__` will be used.
+            params_filename(str|None): The name of file to save all related parameters.
+                                            If it is set None, parameters will be saved
+                                            in separate files .
+            program_only(bool): If True, It will save inference program only, and do not 
+                                        save params of Program.
+                                        Default: False.
+
+        Returns:
+            list: The fetch variables' name list
+        """
+        assert not fluid.in_dygraph_mode(
+        ), 'Save inference model must in static mode!'
+
+        prog = self._adapter._progs.get('test', None)
+        assert prog, \
+            "Model is not ready, please call `model.prepare()` first"
+
+        infer_prog = prog.clone(for_test=True)
+
+        input_names = [v.name for v in self._adapter._input_vars['test']]
+        endpoints = self._adapter._endpoints['test']['output']
+
+        return fluid.io.save_inference_model(
+            save_dir,
+            input_names,
+            endpoints,
+            self._adapter._executor,
+            main_program=infer_prog,
+            model_filename=model_filename,
+            params_filename=params_filename,
+            program_only=program_only)
+
     def _run_one_epoch(self,
                        data_loader,
                        callbacks,

tests/test_model.py → hapi/tests/dist_mnist.py

@@ -15,9 +15,6 @@
 from __future__ import division
 from __future__ import print_function
 
-# when test, you should add hapi root path to the PYTHONPATH,
-# export PYTHONPATH=PATH_TO_HAPI:$PYTHONPATH
-
 import unittest
 
 import os
@@ -27,125 +24,25 @@ import contextlib
 
 import paddle
 from paddle import fluid
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
-from paddle.io import BatchSampler, DataLoader
 
-from hapi.model import Model, CrossEntropy, Input, Loss, set_device
+from hapi.model import Model, Input, set_device
+from hapi.loss import CrossEntropy
+from hapi.vision.models import LeNet
 from hapi.metrics import Accuracy
 from hapi.callbacks import ProgBarLogger
-from hapi.datasets import MNIST as MnistDataset
-
-
-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):
-        inputs = fluid.layers.reshape(inputs, [-1, 1, 28, 28])
-        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
-
-
-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 TestMnistDataset(MnistDataset):
-    def __init__(self):
-        super(TestMnistDataset, self).__init__(mode='test')
+from hapi.datasets import MNIST
+
+
+class MnistDataset(MNIST):
+    def __init__(self, mode, return_label=True):
+        super(MnistDataset, self).__init__(mode=mode)
+        self.return_label = return_label
 
     def __getitem__(self, idx):
-        return self.images[idx],
+        img = np.reshape(self.images[idx], [1, 28, 28])
+        if self.return_label:
+            return img, np.array(self.labels[idx]).astype('int64')
+        return img,
 
     def __len__(self):
         return len(self.images)
@@ -161,7 +58,7 @@ def get_predict_accuracy(pred, gt):
 
 
 class TestModel(unittest.TestCase):
-    def fit(self, dynamic, is_mlp=False):
+    def fit(self, dynamic):
         device = set_device('gpu')
         fluid.enable_dygraph(device) if dynamic else None
 
@@ -173,12 +70,12 @@ class TestModel(unittest.TestCase):
 
         train_dataset = MnistDataset(mode='train')
         val_dataset = MnistDataset(mode='test')
-        test_dataset = TestMnistDataset()
+        test_dataset = MnistDataset(mode='test', return_label=False)
 
-        model = MNIST() if not is_mlp else MLP()
+        model = LeNet()
         optim = fluid.optimizer.Momentum(
             learning_rate=0.01, momentum=.9, parameter_list=model.parameters())
-        loss = CrossEntropy() if not is_mlp else MyCrossEntropy()
+        loss = CrossEntropy()
         model.prepare(optim, loss, Accuracy(), inputs, labels, device=device)
         cbk = ProgBarLogger(50)
 
@@ -199,18 +96,12 @@ class TestModel(unittest.TestCase):
 
         np.testing.assert_allclose(acc, eval_result['acc'])
 
-    def test_fit_static(self):
+    def test_multiple_gpus_static(self):
         self.fit(False)
 
-    def test_fit_dygraph(self):
+    def test_multiple_gpus_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_datasets.py → hapi/tests/test_datasets.py

@@ -12,25 +12,40 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# when test, you should add hapi root path to the PYTHONPATH,
-# export PYTHONPATH=PATH_TO_HAPI:$PYTHONPATH
-
 import unittest
+import os
 import numpy as np
+import tempfile
+import shutil
+import cv2
 
 from hapi.datasets import *
 
 
 class TestFolderDatasets(unittest.TestCase):
+    def makedata(self):
+        self.data_dir = tempfile.mkdtemp()
+        for i in range(2):
+            sub_dir = os.path.join(self.data_dir, 'class_' + str(i))
+            if not os.path.exists(sub_dir):
+                os.makedirs(sub_dir)
+            for j in range(2):
+                fake_img = (np.random.random(
+                    (32, 32, 3)) * 255).astype('uint8')
+                cv2.imwrite(os.path.join(sub_dir, str(j) + '.jpg'), fake_img)
+
     def test_dataset(self):
-        dataset_folder = DatasetFolder('tests/test_data')
+        self.makedata()
+        dataset_folder = DatasetFolder(self.data_dir)
 
         for _ in dataset_folder:
             pass
 
-        assert len(dataset_folder) == 3
+        assert len(dataset_folder) == 4
         assert len(dataset_folder.classes) == 2
 
+        shutil.rmtree(self.data_dir)
+
 
 class TestMNISTTest(unittest.TestCase):
     def test_main(self):

hapi/tests/test_distributed.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 print_function
+
+import unittest
+import os
+import time
+import six
+import copy
+from argparse import ArgumentParser, REMAINDER
+import paddle
+import paddle.fluid as fluid
+
+from paddle.distributed.utils import *
+import paddle.distributed.cloud_utils as cloud_utils
+
+
+def get_cluster_from_args(selected_gpus):
+    cluster_node_ips = '127.0.0.1'
+    node_ip = '127.0.0.1'
+    use_paddlecloud = False
+    started_port = None
+    node_ips = [x.strip() for x in cluster_node_ips.split(',')]
+
+    node_rank = node_ips.index(node_ip)
+
+    free_ports = None
+    if not use_paddlecloud and len(node_ips) <= 1 and started_port is None:
+        free_ports = find_free_ports(len(selected_gpus))
+        if free_ports is not None:
+            free_ports = list(free_ports)
+    else:
+        started_port = 6070
+
+        free_ports = [
+            x for x in range(started_port, started_port + len(selected_gpus))
+        ]
+    return get_cluster(node_ips, node_ip, free_ports, selected_gpus)
+
+
+def get_gpus(selected_gpus):
+    cuda_visible_devices = os.getenv("CUDA_VISIBLE_DEVICES")
+    if cuda_visible_devices is None or cuda_visible_devices == "":
+        selected_gpus = [x.strip() for x in selected_gpus.split(',')]
+    else:
+        cuda_visible_devices_list = cuda_visible_devices.split(',')
+        for x in selected_gpus.split(','):
+            assert x in cuda_visible_devices_list, "Can't find "\
+            "your selected_gpus %s in CUDA_VISIBLE_DEVICES[%s]."\
+            % (x, cuda_visible_devices)
+        selected_gpus = [
+            cuda_visible_devices_list.index(x.strip())
+            for x in selected_gpus.split(',')
+        ]
+    return selected_gpus
+
+
+def start_local_trainers(cluster,
+                         pod,
+                         training_script,
+                         training_script_args,
+                         log_dir=None):
+    current_env = copy.copy(os.environ.copy())
+    #paddle broadcast ncclUniqueId use socket, and
+    #proxy maybe make trainers unreachable, so delete them.
+    #if we set them to "", grpc will log error message "bad uri"
+    #so just delete them.
+    current_env.pop("http_proxy", None)
+    current_env.pop("https_proxy", None)
+
+    procs = []
+    for idx, t in enumerate(pod.trainers):
+        proc_env = {
+            "FLAGS_selected_gpus": "%s" % ",".join([str(g) for g in t.gpus]),
+            "PADDLE_TRAINER_ID": "%d" % t.rank,
+            "PADDLE_CURRENT_ENDPOINT": "%s" % t.endpoint,
+            "PADDLE_TRAINERS_NUM": "%d" % cluster.trainers_nranks(),
+            "PADDLE_TRAINER_ENDPOINTS": ",".join(cluster.trainers_endpoints())
+        }
+
+        current_env.update(proc_env)
+
+        print("trainer proc env:{}".format(current_env))
+
+        cmd = "python -m coverage run --branch -p " + training_script
+
+        print("start trainer proc:{} env:{}".format(cmd, proc_env))
+
+        fn = None
+
+        proc = subprocess.Popen(cmd.split(" "), env=current_env)
+
+        tp = TrainerProc()
+        tp.proc = proc
+        tp.rank = t.rank
+        tp.log_fn = fn
+        tp.cmd = cmd
+
+        procs.append(tp)
+
+    return procs
+
+
+class TestMultipleGpus(unittest.TestCase):
+    def test_mnist_2gpu(self):
+        if fluid.core.get_cuda_device_count() == 0:
+            return
+
+        selected_gpus = get_gpus('0,1')
+        cluster = None
+        pod = None
+
+        cluster, pod = get_cluster_from_args(selected_gpus)
+
+        procs = start_local_trainers(
+            cluster,
+            pod,
+            training_script='dist_mnist.py',
+            training_script_args=[])
+
+        while True:
+            alive = watch_local_trainers(procs, cluster.trainers_nranks())
+
+            if not alive:
+                print("Local procs complete, POD info:{}".format(pod))
+                break
+            time.sleep(3)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_transforms.py → hapi/tests/test_logger.py

@@ -12,44 +12,37 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# when test, you should add hapi root path to the PYTHONPATH,
-# export PYTHONPATH=PATH_TO_HAPI:$PYTHONPATH
+from __future__ import division
+from __future__ import print_function
+
 import unittest
+import os
+import numpy as np
+import shutil
+import tempfile
 
-from hapi.datasets import DatasetFolder
-import hapi.vision.transforms as transforms
+from hapi.logger import setup_logger
 
 
-class TestTransforms(unittest.TestCase):
-    def do_transform(self, trans):
-        dataset_folder = DatasetFolder('tests/test_data', transform=trans)
+class TestSetupLogger(unittest.TestCase):
+    def setUp(self):
+        self.save_dir = tempfile.mkdtemp()
+        self.save_file = os.path.join(self.save_dir, 'logger.txt')
 
-        for _ in dataset_folder:
-            pass
+    def tearDown(self):
+        shutil.rmtree(self.save_dir)
 
-    def test_trans0(self):
-        normalize = transforms.Normalize(
-            mean=[123.675, 116.28, 103.53], std=[58.395, 57.120, 57.375])
-        trans = transforms.Compose([
-            transforms.RandomResizedCrop(224), transforms.GaussianNoise(),
-            transforms.ColorJitter(
-                brightness=0.4, contrast=0.4, saturation=0.4,
-                hue=0.4), transforms.RandomHorizontalFlip(),
-            transforms.Permute(mode='CHW'), normalize
-        ])
+    def logger(self, output=None):
+        setup_logger(output=output)
 
-        self.do_transform(trans)
+    def test_logger_no_output(self):
+        self.logger()
 
-    def test_trans1(self):
-        trans = transforms.Compose([
-            transforms.Resize(256),
-            transforms.CenterCrop(224),
-        ])
-        self.do_transform(trans)
+    def test_logger_dir(self):
+        self.logger(self.save_dir)
 
-    def test_trans2(self):
-        trans = transforms.Compose([transforms.CenterCropResize(224)])
-        self.do_transform(trans)
+    def test_logger_file(self):
+        self.logger(self.save_file)
 
 
 if __name__ == '__main__':

hapi/tests/test_loss.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 six
+import numpy as np
+import shutil
+import copy
+
+import paddle
+from paddle import fluid
+
+from hapi.model import Model, Input
+from hapi.vision.models import resnet18
+from hapi.loss import CrossEntropy, SoftmaxWithCrossEntropy
+
+
+def stable_softmax(x):
+    """Compute the softmax of vector x in a numerically stable way."""
+    # clip to shiftx, otherwise, when calc loss with
+    # log(exp(shiftx)), may get log(0)=INF
+    shiftx = (x - np.max(x)).clip(-64.)
+    exps = np.exp(shiftx)
+    return exps / np.sum(exps)
+
+
+def randomize_probability(batch_size, class_num, dtype='float32'):
+    prob = np.random.uniform(
+        0.1, 1.0, size=(batch_size, class_num)).astype(dtype)
+    prob_sum = prob.sum(axis=1)
+    for i in six.moves.xrange(len(prob)):
+        prob[i] /= prob_sum[i]
+    return prob
+
+
+def numpy_ce(x, label):
+    return np.asmatrix(
+        [[-np.log(x[i][label[i][0]])] for i in range(x.shape[0])],
+        dtype="float32").mean()
+
+
+class TestLoss(unittest.TestCase):
+    def test_cross_entropy(self):
+        class_num = 100
+        batch_size = 128
+        inputs = [randomize_probability(128, class_num) for _ in range(2)]
+
+        labels = [
+            np.random.randint(
+                0, class_num, (batch_size, 1), dtype="int64") for _ in range(2)
+        ]
+
+        gt_out = [numpy_ce(inputs[i], labels[i]) for i in range(2)]
+
+        fluid.enable_dygraph()
+        cross_entropy = CrossEntropy()
+        out = cross_entropy(
+            [fluid.dygraph.to_variable(x) for x in inputs],
+            [fluid.dygraph.to_variable(label) for label in labels])
+        out = [o.numpy() for o in out]
+
+        for o, g in zip(out, gt_out):
+            np.testing.assert_allclose(o, g, atol=1e-5)
+
+    def test_soft_cross_entronpy(self):
+        class_num = 100
+        batch_size = 128
+
+        inputs = [randomize_probability(128, class_num) for _ in range(2)]
+
+        labels = [
+            np.random.randint(
+                0, class_num, (batch_size, 1), dtype="int64") for _ in range(2)
+        ]
+
+        fluid.enable_dygraph()
+        softmax_cross_entropy = SoftmaxWithCrossEntropy()
+
+        softmax_cross_entropy(
+            [fluid.dygraph.to_variable(x) for x in inputs],
+            [fluid.dygraph.to_variable(label) for label in labels])
+
+        softmax_cross_entropy = SoftmaxWithCrossEntropy(average=False)
+
+        inputs = [randomize_probability(128, class_num)]
+
+        labels = [
+            np.random.randint(
+                0, class_num, (batch_size, 1), dtype="int64")
+        ]
+
+        softmax_cross_entropy([fluid.dygraph.to_variable(x) for x in inputs],
+                              fluid.dygraph.to_variable(labels[0]))
+
+
+if __name__ == '__main__':
+    unittest.main()

hapi/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 cv2
+import numpy as np
+
+import paddle
+from paddle import fluid
+from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
+from paddle.fluid.dygraph.container import Sequential
+from paddle.io import BatchSampler, DataLoader
+
+from hapi.model import Model, Input, set_device
+from hapi.loss import Loss
+from hapi.metrics import Accuracy
+from hapi.datasets import MNIST
+from hapi.vision.models import LeNet
+from hapi.download import get_weights_path_from_url
+
+
+class LeNetDygraph(fluid.dygraph.Layer):
+    """LeNet model from
+    `"LeCun Y, Bottou L, Bengio Y, et al. Gradient-based learning applied to document recognition[J]. Proceedings of the IEEE, 1998, 86(11): 2278-2324.`_
+
+    Args:
+        num_classes (int): output dim of last fc layer. If num_classes <=0, last fc layer 
+                            will not be defined. Default: 10.
+        classifier_activation (str): activation for the last fc layer. Default: 'softmax'.
+    """
+
+    def __init__(self, num_classes=10, classifier_activation='softmax'):
+        super(LeNetDygraph, self).__init__()
+        self.num_classes = num_classes
+        self.features = Sequential(
+            Conv2D(
+                1, 6, 3, stride=1, padding=1),
+            Pool2D(2, 'max', 2),
+            Conv2D(
+                6, 16, 5, stride=1, padding=0),
+            Pool2D(2, 'max', 2))
+
+        if num_classes > 0:
+            self.fc = Sequential(
+                Linear(400, 120),
+                Linear(120, 84),
+                Linear(
+                    84, 10, act=classifier_activation))
+
+    def forward(self, inputs):
+        x = self.features(inputs)
+
+        if self.num_classes > 0:
+            x = fluid.layers.flatten(x, 1)
+            x = self.fc(x)
+        return x
+
+
+class MnistDataset(MNIST):
+    def __init__(self, mode, return_label=True):
+        super(MnistDataset, self).__init__(mode=mode)
+        self.return_label = return_label
+
+    def __getitem__(self, idx):
+        img = np.reshape(self.images[idx], [1, 28, 28])
+        if self.return_label:
+            return img, np.array(self.labels[idx]).astype('int64')
+        return img,
+
+    def __len__(self):
+        return len(self.images)
+
+
+def get_predict_accuracy(pred, gt):
+    pred = np.argmax(pred, -1)
+    gt = np.array(gt)
+
+    correct = pred[:, np.newaxis] == gt
+    return np.sum(correct) / correct.shape[0]
+
+
+def low_level_lenet_dygraph_train(model, dataloader):
+    optim = fluid.optimizer.Adam(
+        learning_rate=0.001, parameter_list=model.parameters())
+    model.train()
+    for inputs, labels in dataloader:
+        outputs = model(inputs)
+        loss = fluid.layers.cross_entropy(outputs, labels)
+        avg_loss = fluid.layers.reduce_sum(loss)
+        avg_loss.backward()
+        optim.minimize(avg_loss)
+        model.clear_gradients()
+
+
+def low_level_dynamic_evaluate(model, dataloader):
+    with fluid.dygraph.no_grad():
+        model.eval()
+        cnt = 0
+        for inputs, labels in dataloader:
+            outputs = model(inputs)
+
+            cnt += (np.argmax(outputs.numpy(), -1)[:, np.newaxis] ==
+                    labels.numpy()).astype('int').sum()
+
+    return cnt / len(dataloader.dataset)
+
+
+class TestEvaluatePredict(unittest.TestCase):
+    def setUp(self):
+        self.device = set_device('gpu')
+        self.train_dataset = MnistDataset(mode='train')
+        self.val_dataset = MnistDataset(mode='test')
+        self.test_dataset = MnistDataset(mode='test', return_label=False)
+
+        fluid.enable_dygraph(self.device)
+        train_dataloader = fluid.io.DataLoader(
+            self.train_dataset, places=self.device, batch_size=64)
+        val_dataloader = fluid.io.DataLoader(
+            self.val_dataset, places=self.device, batch_size=64)
+        self.lenet_dygraph = LeNetDygraph()
+        low_level_lenet_dygraph_train(self.lenet_dygraph, train_dataloader)
+        self.acc1 = low_level_dynamic_evaluate(self.lenet_dygraph,
+                                               val_dataloader)
+
+    def evaluate(self, dynamic):
+        fluid.enable_dygraph(self.device) if dynamic else None
+
+        inputs = [Input([-1, 1, 28, 28], '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]
+
+        self.train_dataloader = fluid.io.DataLoader(
+            self.train_dataset,
+            places=self.device,
+            batch_size=64,
+            feed_list=feed_list)
+        self.val_dataloader = fluid.io.DataLoader(
+            self.val_dataset,
+            places=self.device,
+            batch_size=64,
+            feed_list=feed_list)
+        self.test_dataloader = fluid.io.DataLoader(
+            self.test_dataset,
+            places=self.device,
+            batch_size=64,
+            feed_list=feed_list)
+
+        model = LeNet()
+        model.load_dict(self.lenet_dygraph.state_dict())
+        model.prepare(metrics=Accuracy(), inputs=inputs, labels=labels)
+
+        result = model.evaluate(self.val_dataloader)
+
+        np.testing.assert_allclose(result['acc'], self.acc1)
+
+    def predict(self, dynamic):
+        fluid.enable_dygraph(self.device) if dynamic else None
+
+        inputs = [Input([-1, 1, 28, 28], '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]
+
+        self.train_dataloader = fluid.io.DataLoader(
+            self.train_dataset,
+            places=self.device,
+            batch_size=64,
+            feed_list=feed_list)
+        self.val_dataloader = fluid.io.DataLoader(
+            self.val_dataset,
+            places=self.device,
+            batch_size=64,
+            feed_list=feed_list)
+        self.test_dataloader = fluid.io.DataLoader(
+            self.test_dataset,
+            places=self.device,
+            batch_size=64,
+            feed_list=feed_list)
+
+        model = LeNet()
+        model.load_dict(self.lenet_dygraph.state_dict())
+        model.prepare(metrics=Accuracy(), inputs=inputs, labels=labels)
+
+        output = model.predict(self.test_dataloader, stack_outputs=True)
+
+        np.testing.assert_equal(output[0].shape[0], len(self.test_dataset))
+
+        acc = get_predict_accuracy(output[0], self.val_dataset.labels)
+
+        np.testing.assert_allclose(acc, self.acc1)
+
+    def test_evaluate_dygraph(self):
+        self.evaluate(True)
+
+    def test_evaluate_static(self):
+        self.evaluate(False)
+
+    def test_predict_dygraph(self):
+        self.predict(True)
+
+    def test_predict_static(self):
+        self.predict(False)
+
+
+if __name__ == '__main__':
+    unittest.main()

hapi/tests/test_save_inference_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 shutil
+import tempfile
+
+import paddle
+from paddle import fluid
+
+from hapi.model import Model, Input
+from hapi.vision.models import resnet18
+
+
+class TestSaveInferenceModel(unittest.TestCase):
+    def tearDown(self):
+        shutil.rmtree(self.save_dir)
+
+    def export_deploy_model(self):
+        model = resnet18()
+
+        inputs = [Input([None, 3, 224, 224], 'float32', name='image')]
+
+        model.prepare(inputs=inputs)
+
+        self.save_dir = tempfile.mkdtemp()
+        if not os.path.exists(self.save_dir):
+            os.makedirs(self.save_dir)
+
+        model.save_inference_model(self.save_dir)
+
+        place = fluid.CPUPlace() if not fluid.is_compiled_with_cuda(
+        ) else fluid.CUDAPlace(0)
+        exe = fluid.Executor(place)
+
+        [inference_program, feed_target_names, fetch_targets] = (
+            fluid.io.load_inference_model(
+                dirname=self.save_dir, executor=exe))
+        tensor_img = np.array(
+            np.random.random((1, 3, 224, 224)), dtype=np.float32)
+        ori_results = model.test_batch(tensor_img)
+        results = exe.run(inference_program,
+                          feed={feed_target_names[0]: tensor_img},
+                          fetch_list=fetch_targets)
+
+        np.testing.assert_allclose(results, ori_results)
+
+    def test_save_inference_model(self):
+        self.export_deploy_model()
+
+
+if __name__ == '__main__':
+    unittest.main()

hapi/tests/test_transforms.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.
+
+# when test, you should add hapi root path to the PYTHONPATH,
+# export PYTHONPATH=PATH_TO_HAPI:$PYTHONPATH
+import unittest
+import os
+import tempfile
+import cv2
+import shutil
+import numpy as np
+
+from hapi.datasets import DatasetFolder
+import hapi.vision.transforms as transforms
+
+
+class TestTransforms(unittest.TestCase):
+    def setUp(self):
+        self.data_dir = tempfile.mkdtemp()
+        for i in range(2):
+            sub_dir = os.path.join(self.data_dir, 'class_' + str(i))
+            if not os.path.exists(sub_dir):
+                os.makedirs(sub_dir)
+            for j in range(2):
+                if j == 0:
+                    fake_img = (np.random.random(
+                        (280, 350, 3)) * 255).astype('uint8')
+                else:
+                    fake_img = (np.random.random(
+                        (400, 300, 3)) * 255).astype('uint8')
+                cv2.imwrite(os.path.join(sub_dir, str(j) + '.jpg'), fake_img)
+
+    def tearDown(self):
+        shutil.rmtree(self.data_dir)
+
+    def do_transform(self, trans):
+        dataset_folder = DatasetFolder(self.data_dir, transform=trans)
+
+        for _ in dataset_folder:
+            pass
+
+    def test_trans_all(self):
+        normalize = transforms.Normalize(
+            mean=[123.675, 116.28, 103.53], std=[58.395, 57.120, 57.375])
+        trans = transforms.Compose([
+            transforms.RandomResizedCrop(224), transforms.GaussianNoise(),
+            transforms.ColorJitter(
+                brightness=0.4, contrast=0.4, saturation=0.4,
+                hue=0.4), transforms.RandomHorizontalFlip(),
+            transforms.Permute(mode='CHW'), normalize
+        ])
+
+        self.do_transform(trans)
+
+    def test_trans_resize(self):
+        trans = transforms.Compose([
+            transforms.Resize(300, [0, 1]),
+            transforms.RandomResizedCrop((280, 280)),
+            transforms.Resize(280, [0, 1]),
+            transforms.Resize((256, 200)),
+            transforms.Resize((180, 160)),
+            transforms.CenterCrop(128),
+            transforms.CenterCrop((128, 128)),
+        ])
+        self.do_transform(trans)
+
+    def test_trans_centerCrop(self):
+        trans = transforms.Compose([
+            transforms.CenterCropResize(224),
+            transforms.CenterCropResize(128, 160),
+        ])
+        self.do_transform(trans)
+
+    def test_flip(self):
+        trans = transforms.Compose([
+            transforms.RandomHorizontalFlip(1.0),
+            transforms.RandomHorizontalFlip(0.0),
+            transforms.RandomVerticalFlip(0.0),
+            transforms.RandomVerticalFlip(1.0),
+        ])
+        self.do_transform(trans)
+
+    def test_color_jitter(self):
+        trans = transforms.BatchCompose([
+            transforms.BrightnessTransform(0.0),
+            transforms.HueTransform(0.0),
+            transforms.SaturationTransform(0.0),
+            transforms.ContrastTransform(0.0),
+        ])
+        self.do_transform(trans)
+
+    def test_exception(self):
+        trans = transforms.Compose([transforms.Resize(-1)])
+
+        trans_batch = transforms.BatchCompose([transforms.Resize(-1)])
+
+        with self.assertRaises(Exception):
+            self.do_transform(trans)
+
+        with self.assertRaises(Exception):
+            self.do_transform(trans_batch)
+
+        with self.assertRaises(ValueError):
+            transforms.ContrastTransform(-1.0)
+
+        with self.assertRaises(ValueError):
+            transforms.SaturationTransform(-1.0),
+
+        with self.assertRaises(ValueError):
+            transforms.HueTransform(-1.0)
+
+        with self.assertRaises(ValueError):
+            transforms.BrightnessTransform(-1.0)
+
+    def test_info(self):
+        str(transforms.Compose([transforms.Resize((224, 224))]))
+        str(transforms.BatchCompose([transforms.Resize((224, 224))]))
+
+
+if __name__ == '__main__':
+    unittest.main()

hapi/tests/test_vison_models.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 numpy as np
+
+import hapi.vision.models as models
+from hapi.model import Input
+
+
+class TestVisonModels(unittest.TestCase):
+    def models_infer(self, arch, pretrained=False, batch_norm=False):
+
+        x = np.array(np.random.random((2, 3, 224, 224)), dtype=np.float32)
+        if batch_norm:
+            model = models.__dict__[arch](pretrained=pretrained,
+                                          batch_norm=True)
+        else:
+            model = models.__dict__[arch](pretrained=pretrained)
+        inputs = [Input([None, 3, 224, 224], 'float32', name='image')]
+
+        model.prepare(inputs=inputs)
+
+        model.test_batch(x)
+
+    def test_mobilenetv2_pretrained(self):
+        self.models_infer('mobilenet_v2', pretrained=True)
+
+    def test_mobilenetv1(self):
+        self.models_infer('mobilenet_v1')
+
+    def test_vgg11(self):
+        self.models_infer('vgg11')
+
+    def test_vgg13(self):
+        self.models_infer('vgg13')
+
+    def test_vgg16(self):
+        self.models_infer('vgg16')
+
+    def test_vgg16_bn(self):
+        self.models_infer('vgg16', batch_norm=True)
+
+    def test_vgg19(self):
+        self.models_infer('vgg19')
+
+    def test_resnet18(self):
+        self.models_infer('resnet18')
+
+    def test_resnet34(self):
+        self.models_infer('resnet34')
+
+    def test_resnet50(self):
+        self.models_infer('resnet50')
+
+    def test_resbet101(self):
+        self.models_infer('resnet101')
+
+    def test_resbet152(self):
+        self.models_infer('resnet152')
+
+    def test_darknet53(self):
+        self.models_infer('darknet53')
+
+    def test_lenet(self):
+        lenet = models.__dict__['LeNet']()
+
+        inputs = [Input([None, 1, 28, 28], 'float32', name='x')]
+        lenet.prepare(inputs=inputs)
+
+        x = np.array(np.random.random((2, 1, 28, 28)), dtype=np.float32)
+        lenet.test_batch(x)
+
+
+if __name__ == '__main__':
+    unittest.main()

hapi/utils.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 inspect
+import numpy as np
+
+from paddle import fluid
+from paddle.fluid.framework import Variable
+from paddle.fluid.executor import global_scope
+
+
+def to_list(value):
+    if value is None:
+        return value
+    if isinstance(value, (list, tuple)):
+        return list(value)
+    return [value]
+
+
+def to_numpy(var):
+    assert isinstance(var, (Variable, fluid.core.VarBase)), "not a variable"
+    if isinstance(var, fluid.core.VarBase):
+        return var.numpy()
+    t = global_scope().find_var(var.name).get_tensor()
+    return np.array(t)
+
+
+def flatten_list(l):
+    assert isinstance(l, list), "not a list"
+    outl = []
+    splits = []
+    for sl in l:
+        assert isinstance(sl, list), "sub content not a list"
+        splits.append(len(sl))
+        outl += sl
+    return outl, splits
+
+
+def restore_flatten_list(l, splits):
+    outl = []
+    for split in splits:
+        assert len(l) >= split, "list length invalid"
+        sl, l = l[:split], l[split:]
+        outl.append(sl)
+    return outl
+
+
+def extract_args(func):
+    if hasattr(inspect, 'getfullargspec'):
+        return inspect.getfullargspec(func)[0]
+    else:
+        return inspect.getargspec(func)[0]
\ No newline at end of file

hapi/vision/models/__init__.py

@@ -17,15 +17,18 @@ from . import vgg
 from . import mobilenetv1
 from . import mobilenetv2
 from . import darknet
+from . import lenet
 
 from .resnet import *
 from .mobilenetv1 import *
 from .mobilenetv2 import *
 from .vgg import *
 from .darknet import *
+from .lenet import *
 
 __all__ = resnet.__all__ \
         + vgg.__all__ \
         + mobilenetv1.__all__ \
         + mobilenetv2.__all__ \
-        + darknet.__all__
+        + darknet.__all__\
+        + lenet.__all__

hapi/vision/models/darknet.py

@@ -20,14 +20,15 @@ from paddle.fluid.regularizer import L2Decay
 from paddle.fluid.dygraph.nn import Conv2D, BatchNorm, Pool2D, Linear
 
 from hapi.model import Model
-from hapi.download import get_weights_path
+from hapi.download import get_weights_path_from_url
 
 __all__ = ['DarkNet', 'darknet53']
 
 # {num_layers: (url, md5)}
-pretrain_infos = {
-    53: ('https://paddle-hapi.bj.bcebos.com/models/darknet53.pdparams',
-         'ca506a90e2efecb9a2093f8ada808708')
+model_urls = {
+    'darknet53':
+    ('https://paddle-hapi.bj.bcebos.com/models/darknet53.pdparams',
+     'ca506a90e2efecb9a2093f8ada808708')
 }
 
 
@@ -213,16 +214,15 @@ class DarkNet(Model):
         return out
 
 
-def _darknet(num_layers=53, pretrained=False, **kwargs):
+def _darknet(arch, num_layers=53, pretrained=False, **kwargs):
     model = DarkNet(num_layers, **kwargs)
     if pretrained:
-        assert num_layers in pretrain_infos.keys(), \
-                "DarkNet{} do not have pretrained weights now, " \
-                "pretrained should be set as False".format(num_layers)
-        weight_path = get_weights_path(*(pretrain_infos[num_layers]))
+        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_from_url(*(model_urls[arch]))
         assert weight_path.endswith('.pdparams'), \
                 "suffix of weight must be .pdparams"
-        model.load(weight_path[:-9])
+        model.load(weight_path)
     return model
 
 
@@ -234,4 +234,4 @@ def darknet53(pretrained=False, **kwargs):
         pretrained (bool): If True, returns a model pre-trained on ImageNet,
             default True.
     """
-    return _darknet(53, pretrained, **kwargs)
+    return _darknet('darknet53', 53, pretrained, **kwargs)

hapi/vision/models/mobilenetv1.py

@@ -20,7 +20,7 @@ from paddle.fluid.param_attr import ParamAttr
 from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
 
 from hapi.model import Model
-from hapi.download import get_weights_path
+from hapi.download import get_weights_path_from_url
 
 __all__ = ['MobileNetV1', 'mobilenet_v1']
 
@@ -267,11 +267,11 @@ def _mobilenet(arch, pretrained=False, **kwargs):
     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][0],
-                                       model_urls[arch][1])
+        weight_path = get_weights_path_from_url(model_urls[arch][0],
+                                                model_urls[arch][1])
         assert weight_path.endswith(
             '.pdparams'), "suffix of weight must be .pdparams"
-        model.load(weight_path[:-9])
+        model.load(weight_path)
 
     return model
 

hapi/vision/models/mobilenetv2.py

@@ -19,7 +19,7 @@ from paddle.fluid.param_attr import ParamAttr
 from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
 
 from hapi.model import Model
-from hapi.download import get_weights_path
+from hapi.download import get_weights_path_from_url
 
 __all__ = ['MobileNetV2', 'mobilenet_v2']
 
@@ -241,11 +241,11 @@ def _mobilenet(arch, pretrained=False, **kwargs):
     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][0],
-                                       model_urls[arch][1])
+        weight_path = get_weights_path_from_url(model_urls[arch][0],
+                                                model_urls[arch][1])
         assert weight_path.endswith(
             '.pdparams'), "suffix of weight must be .pdparams"
-        model.load(weight_path[:-9])
+        model.load(weight_path)
 
     return model
 

hapi/vision/models/resnet.py

@@ -23,7 +23,7 @@ from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
 from paddle.fluid.dygraph.container import Sequential
 
 from hapi.model import Model
-from hapi.download import get_weights_path
+from hapi.download import get_weights_path_from_url
 
 __all__ = [
     'ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152'
@@ -267,11 +267,11 @@ def _resnet(arch, Block, depth, pretrained, **kwargs):
     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][0],
-                                       model_urls[arch][1])
+        weight_path = get_weights_path_from_url(model_urls[arch][0],
+                                                model_urls[arch][1])
         assert weight_path.endswith(
             '.pdparams'), "suffix of weight must be .pdparams"
-        model.load(weight_path[:-9])
+        model.load(weight_path)
     return model
 
 

hapi/vision/models/vgg.py

@@ -18,7 +18,7 @@ from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
 from paddle.fluid.dygraph.container import Sequential
 
 from hapi.model import Model
-from hapi.download import get_weights_path
+from hapi.download import get_weights_path_from_url
 
 __all__ = [
     'VGG',
@@ -128,11 +128,11 @@ def _vgg(arch, cfg, batch_norm, pretrained, **kwargs):
     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][0],
-                                       model_urls[arch][1])
+        weight_path = get_weights_path_from_url(model_urls[arch][0],
+                                                model_urls[arch][1])
         assert weight_path.endswith(
             '.pdparams'), "suffix of weight must be .pdparams"
-        model.load(weight_path[:-9])
+        model.load(weight_path)
 
     return model
 

mnist.py

@@ -26,7 +26,8 @@ from paddle.fluid.optimizer import Momentum
 from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
 from hapi.datasets.mnist import MNIST as MnistDataset
 
-from hapi.model import Model, CrossEntropy, Input, set_device
+from hapi.model import Model, Input, set_device
+from hapi.loss import CrossEntropy
 from hapi.metrics import Accuracy