Refine Model of high level API (#25559)

* Refine Model

1. Take the network (instance of Layer) as the input of Model.
2. Refine set_dict/load_dict of Layer.
3. Refine Input interface, so update code sample about Input

Author: qingqing01

python/paddle/fluid/dygraph/checkpoint.py

@@ -94,7 +94,9 @@ def save_dygraph(state_dict, model_path):
         pickle.dump(model_dict, f, protocol=2)
 
 
-@dygraph_only
+# TODO(qingqing01): remove dygraph_only to support loading static model.
+# maybe need to unify the loading interface after 2.0 API is ready.
+#@dygraph_only
 def load_dygraph(model_path, keep_name_table=False):
     '''
     :api_attr: imperative

python/paddle/fluid/dygraph/layers.py

@@ -16,19 +16,19 @@
 import contextlib
 import sys
 import numpy as np
-import collections
 import six
 import re
+import copy
+import weakref
+import warnings
+
 from . import parallel_helper
 from .. import unique_name
 from paddle.fluid import core
 from .layer_object_helper import LayerObjectHelper
 from .base import program_desc_tracing_guard, param_guard
 from paddle.fluid import framework
 from ..param_attr import ParamAttr
-import copy
-import weakref
-import warnings
 
 __all__ = ['Layer']
 

python/paddle/fluid/framework.py

@@ -66,7 +66,6 @@
 _dygraph_tracer_ = None
 _dygraph_current_expected_place_ = None
 _current_device = None
-
 global_prog_seed = 0
 
 

python/paddle/incubate/hapi/__init__.py

@@ -16,14 +16,22 @@
 from . import progressbar
 from . import callbacks
 from . import download
+
 from . import model
+from .model import *
+
 from . import metrics
 from . import loss
 from . import datasets
 from . import distributed
 from . import vision
 from . import text
 
+from . import device
+from .device import *
+
+from .dygraph_layer_patch import monkey_patch_layer
+
 logger.setup_logger()
 
 __all__ = [
@@ -35,6 +43,6 @@
     'loss',
     'vision',
     'text',
-]
+] + model.__all__ + device.__all__
 
-__all__ += model.__all__
+monkey_patch_layer()

python/paddle/incubate/hapi/callbacks.py

@@ -291,30 +291,22 @@ class ProgBarLogger(Callback):
     Examples:
         .. code-block:: python
 
-            import numpy as np
-            from paddle import fluid
-            from paddle.incubate.hapi.metrics import Accuracy
-            from paddle.incubate.hapi.loss import CrossEntropy
-            from paddle.incubate.hapi.datasets import MNIST
-            from paddle.incubate.hapi.vision.models import LeNet
-            from paddle.incubate.hapi.callbacks import ProgBarLogger
-            from paddle.incubate.hapi.model import Input, set_device
+            import paddle.fluid as fluid
+            import paddle.incubate.hapi as hapi
 
-            inputs = [Input([-1, 1, 28, 28], 'float32', name='image')]
-            labels = [Input([None, 1], 'int64', name='label')]
+            inputs = [hapi.Input('image', [-1, 1, 28, 28], 'float32')]
+            labels = [hapi.Input('label', [None, 1], 'int64')]
 
-            train_dataset = MNIST(mode='train')
+            train_dataset = hapi.datasets.MNIST(mode='train')
 
-            model = LeNet()
+            model = hapi.Model(hapi.vision.LeNet(), inputs, labels)
 
             optim = fluid.optimizer.Adam(0.001)
-            model.prepare(optimizer=optim, 
-                        loss_function=CrossEntropy(), 
-                        metrics=Accuracy(), 
-                        inputs=inputs, 
-                        labels=labels)
+            model.prepare(optimizer=optim,
+                        loss_function=hapi.loss.CrossEntropy(),
+                        metrics=hapi.metrics.Accuracy())
 
-            callback = ProgBarLogger(log_freq=10)
+            callback = hapi.callbacks.ProgBarLogger(log_freq=10)
             model.fit(train_dataset, batch_size=64, callbacks=callback)
     """
 
@@ -433,31 +425,22 @@ class ModelCheckpoint(Callback):
     Examples:
         .. code-block:: python
 
-            import numpy as np
-            from paddle import fluid
-            from paddle.incubate.hapi.metrics import Accuracy
-            from paddle.incubate.hapi.loss import CrossEntropy
-            from paddle.incubate.hapi.datasets import MNIST
-            
-            from paddle.incubate.hapi.vision.models import LeNet
-            from paddle.incubate.hapi.callbacks import ModelCheckpoint
-            from paddle.incubate.hapi.model import Input, set_device
+            import paddle.fluid as fluid
+            import paddle.incubate.hapi as hapi
 
-            inputs = [Input([-1, 1, 28, 28], 'float32', name='image')]
-            labels = [Input([None, 1], 'int64', name='label')]
+            inputs = [hapi.Input('image', [-1, 1, 28, 28], 'float32')]
+            labels = [hapi.Input('label', [None, 1], 'int64')]
 
-            train_dataset = MNIST(mode='train')
+            train_dataset = hapi.datasets.MNIST(mode='train')
 
-            model = LeNet()
+            model = hapi.Model(hapi.vision.LeNet(), inputs, labels)
 
             optim = fluid.optimizer.Adam(0.001)
-            model.prepare(optimizer=optim, 
-                        loss_function=CrossEntropy(), 
-                        metrics=Accuracy(), 
-                        inputs=inputs, 
-                        labels=labels)
+            model.prepare(optimizer=optim,
+                        loss_function=hapi.loss.CrossEntropy(),
+                        metrics=hapi.metrics.Accuracy())
 
-            callback = ModelCheckpoint(save_dir='./temp')
+            callback = hapi.callbacks.ModelCheckpoint(save_dir='./temp')
             model.fit(train_dataset, batch_size=64, callbacks=callback)
     """
 

python/paddle/incubate/hapi/device.py

@@ -0,0 +1,66 @@
+#   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 paddle.fluid as fluid
+from paddle.fluid.dygraph.parallel import ParallelEnv
+
+__all__ = ['set_device', ]
+
+# TODO(qingqing01): remove or refine _global_device, set_device and get_device
+# after core framework supporting these function.
+_global_device = None
+
+
+def set_device(device):
+    """
+    Args:
+        device (str): specify device type, 'cpu' or 'gpu'.
+        
+    Returns:
+        fluid.CUDAPlace or fluid.CPUPlace: Created GPU or CPU place.
+
+    Examples:
+        .. code-block:: python
+
+        import paddle.incubate.hapi as hapi
+
+        input = hapi.set_device('gpu')
+    """
+
+    assert isinstance(device, six.string_types) and device.lower() in ['cpu', 'gpu'], \
+    "Expected device in ['cpu', 'gpu'], but got {}".format(device)
+
+    device = fluid.CUDAPlace(ParallelEnv().dev_id) \
+            if device.lower() == 'gpu' and fluid.is_compiled_with_cuda() \
+                else fluid.CPUPlace()
+
+    global _global_device
+    _global_device = device
+    return device
+
+
+def _get_device():
+    """
+    Return global device.
+    """
+    if _global_device is not None:
+        device = _global_device
+    else:
+        if fluid.is_compiled_with_cuda():
+            device = fluid.CUDAPlace(ParallelEnv().dev_id)
+        else:
+            device = fluid.CPUPlace()
+    return device

python/paddle/incubate/hapi/dygraph_layer_patch.py

@@ -0,0 +1,104 @@
+# 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 warnings
+
+import paddle.fluid as fluid
+from paddle.fluid.framework import in_dygraph_mode
+
+from .device import _get_device
+
+
+def monkey_patch_layer():
+    def load_dict(self,
+                  stat_dict,
+                  include_sublayers=True,
+                  use_structured_name=True):
+        '''
+        Set parameters from stat_dict. All the parameters will be reset by the
+        tensor in the stat_dict
+
+        This api will be Deprecated. Please use set_dict
+
+        Parameters:
+            state_dict(dict) : Dict contains all the parameters
+            include_sublayers(bool, optional) : If true, also include the
+                parameters from sublayers. Default: True
+            use_structured_name(bool, optional) : If true, use structured name
+                as key, otherwise, use parameter name as key. Default: True
+        Returns:
+            None
+
+        Examples:
+            .. code-block:: python
+
+                import paddle.fluid as fluid
+                with fluid.dygraph.guard():
+                    emb = fluid.dygraph.Embedding([10, 10])
+
+                    state_dict = emb.state_dict()
+                    fluid.save_dygraph( state_dict, "paddle_dy")
+                    
+                    para_state_dict, _ = fluid.load_dygraph( "paddle_dy")
+                    emb.load_dict( para_state_dict )
+
+        '''
+
+        def _check_match(key, param):
+            state = stat_dict.get(key, None)
+            if state is None:
+                raise ValueError(
+                    "{} is not found in the providing file.".format(key))
+            if list(state.shape) != list(param.shape):
+                raise ValueError(
+                    "{} receives a shape {}, but the expected shape is {}.".
+                    format(key, list(state.shape), list(param.shape)))
+            return param, state
+
+        matched_param_state = []
+        for key, param in self.state_dict().items():
+            key_name = key if use_structured_name else param.name
+            try:
+                match_res = _check_match(key_name, param)
+            except ValueError as err:
+                warnings.warn(("Skip loading for {}. ".format(key) + str(err)))
+            matched_param_state.append(match_res)
+
+        if in_dygraph_mode():
+            for param, state in matched_param_state:
+                param.set_value(state)
+        else:
+
+            def _set_var(var, ndarray):
+                t = fluid.global_scope().find_var(var.name).get_tensor()
+                p = t._place()
+                if p.is_cpu_place():
+                    place = fluid.CPUPlace()
+                elif p.is_cuda_pinned_place():
+                    place = fluid.CUDAPinnedPlace()
+                else:
+                    p = fluid.core.Place()
+                    p.set_place(t._place())
+                    place = fluid.CUDAPlace(p.gpu_device_id())
+                t.set(ndarray, place)
+
+            executor = fluid.Executor(_get_device())._default_executor
+            # restore parameter states
+            fluid.core._create_loaded_parameter(
+                [param for param, state in matched_param_state],
+                fluid.global_scope(), executor)
+            for param, state in matched_param_state:
+                _set_var(param, state)
+
+    setattr(fluid.dygraph.Layer, 'load_dict', load_dict)

python/paddle/incubate/hapi/loss.py

@@ -86,16 +86,13 @@ class CrossEntropy(Loss):
     Examples:
         .. code-block:: python
 
-            from paddle.incubate.hapi.model import Input
-            from paddle.incubate.hapi.vision.models import LeNet
-            from paddle.incubate.hapi.loss import CrossEntropy
+            import paddle.fluid as fluid
+            import paddle.incubate.hapi as hapi
 
-            inputs = [Input([-1, 1, 28, 28], 'float32', name='image')]
-            labels = [Input([None, 1], 'int64', name='label')]
+            fluid.enable_dygraph()
 
-            model = LeNet()
-            loss = CrossEntropy()
-            model.prepare(loss_function=loss, inputs=inputs, labels=labels)
+            model = hapi.Model(hapi.vision.LeNet())
+            model.prepare(loss_function=hapi.loss.CrossEntropy())
             
     """
 
@@ -123,16 +120,14 @@ class SoftmaxWithCrossEntropy(Loss):
     Examples:
         .. code-block:: python
 
-            from paddle.incubate.hapi.model import Input
-            from paddle.incubate.hapi.vision.models import LeNet
-            from paddle.incubate.hapi.loss import SoftmaxWithCrossEntropy
+            import paddle.fluid as fluid
+            import paddle.incubate.hapi as hapi
 
-            inputs = [Input([-1, 1, 28, 28], 'float32', name='image')]
-            labels = [Input([None, 1], 'int64', name='label')]
+            fluid.enable_dygraph()
 
-            model = LeNet(classifier_activation=None)
-            loss = SoftmaxWithCrossEntropy()
-            model.prepare(loss_function=loss, inputs=inputs, labels=labels)
+            model = hapi.Model(hapi.vision.LeNet(classifier_activation=None))
+            loss = hapi.loss.SoftmaxWithCrossEntropy()
+            model.prepare(loss_function=loss)
     """
 
     def __init__(self, average=True):