Fix comments.

test=develop

Author: wanghaoshuang

python/paddle/fluid/contrib/slim/nas/light_nas_strategy.py

@@ -136,21 +136,20 @@ def _constrain_func(self, tokens, context=None):
             return False
 
     def on_epoch_begin(self, context):
-        _logger.info("light nas strategy on_epoch_begin")
         if context.epoch_id >= self.start_epoch and context.epoch_id <= self.end_epoch and (
                 self._retrain_epoch == 0 or
             (context.epoch_id - self.start_epoch) % self._retrain_epoch == 0):
-            _logger.info("Construct new program...")
+            _logger.info("light nas strategy on_epoch_begin")
             for _ in range(self._max_try_times):
                 startup_p, train_p, test_p, _, _, train_reader, test_reader = context.search_space.create_net(
                     self._current_tokens)
+                _logger.info("try [{}]".format(self._current_tokens))
                 context.eval_graph.program = test_p
                 flops = context.eval_graph.flops()
                 if flops <= self._max_flops:
                     break
                 else:
                     self._current_tokens = self._search_agent.next_tokens()
-                    _logger.info("try [{}]".format(self._current_tokens))
 
             context.train_reader = train_reader
             context.eval_reader = test_reader

python/paddle/fluid/contrib/slim/prune/auto_prune_strategy.py

@@ -66,7 +66,7 @@ def __init__(self,
 
     def on_compression_begin(self, context):
         """
-        Prepare some information for searching stategy.
+        Prepare some information for searching strategy.
         step 1: Find all the parameters to be pruned.
         step 2: Get initial tokens and setup controller.
         """

python/paddle/fluid/contrib/slim/tests/light_nas/light_nasnet.py

@@ -90,14 +90,14 @@ def net(self, input, bottleneck_params_list=None, class_dim=1000,
             i += 1
             input = self.invresi_blocks(
                 input=input,
-                in_c=in_c,
-                t=t,
-                c=int(c * scale),
-                n=n,
-                s=s,
-                k=k,
-                ifshortcut=ifshortcut,
-                ifse=ifse,
+                in_channel=in_c,
+                expansion=t,
+                out_channel=int(c * scale),
+                num_layers=n,
+                stride=s,
+                filter_size=k,
+                shortcut=ifshortcut,
+                squeeze=ifse,
                 name='conv' + str(i))
             in_c = int(c * scale)
         #last_conv
@@ -230,15 +230,15 @@ def inverted_residual_unit(self,
                                name=None):
         """Build inverted residual unit.
         Args:
-            input: Variable, input.
-            num_in_filter: int, number of in filters.
-            num_filters: int, number of filters.
-            ifshortcut: bool, whether using shortcut.
-            stride: int, stride.
-            filter_size: int, filter size.
-            padding: int, padding.
-            expansion_factor: float, expansion factor.
-            name: str, name.
+            input(Variable): Theinput.
+            num_in_filter(int): The number of input filters.
+            num_filters(int): The number of filters.
+            ifshortcut(bool): Whether to use shortcut.
+            stride(int): The stride.
+            filter_size(int): The filter size.
+            padding(int): The padding.
+            expansion_factor(float): Expansion factor.
+            name(str): The name.
         Returns:
             Variable, layers output.
         """
@@ -287,53 +287,53 @@ def inverted_residual_unit(self,
 
     def invresi_blocks(self,
                        input,
-                       in_c,
-                       t,
-                       c,
-                       n,
-                       s,
-                       k,
-                       ifshortcut,
-                       ifse,
+                       in_channel,
+                       expansion,
+                       out_channel,
+                       num_layers,
+                       stride,
+                       filter_size,
+                       shortcut,
+                       squeeze,
                        name=None):
         """Build inverted residual blocks.
         Args:
-            input: Variable, input.
-            in_c: int, number of in filters.
-            t: float, expansion factor.
-            c: int, number of filters.
-            n: int, number of layers.
-            s: int, stride.
-            k: int, filter size.
-            ifshortcut: bool, if adding shortcut layers or not.
-            ifse: bool, if adding squeeze excitation layers or not.
-            name: str, name.
+            input(Variable): The input feture map.
+            in_channel(int): The number of input channel.
+            expansion(float): Expansion factor.
+            out_channel(int): The number of output channel.
+            num_layers(int): The number of layers.
+            stride(int): The stride.
+            filter_size(int): The size of filter.
+            shortcut(bool): Whether to add shortcut layers.
+            squeeze(bool): Whether to add squeeze excitation layers.
+            name(str): The name.
         Returns:
             Variable, layers output.
         """
         first_block = self.inverted_residual_unit(
             input=input,
-            num_in_filter=in_c,
-            num_filters=c,
+            num_in_filter=in_channel,
+            num_filters=out_channel,
             ifshortcut=False,
-            ifse=ifse,
-            stride=s,
-            filter_size=k,
-            expansion_factor=t,
+            ifse=squeeze,
+            stride=stride,
+            filter_size=filter_size,
+            expansion_factor=expansion,
             name=name + '_1')
 
         last_residual_block = first_block
-        last_c = c
+        last_c = out_channel
 
-        for i in range(1, n):
+        for i in range(1, num_layers):
             last_residual_block = self.inverted_residual_unit(
                 input=last_residual_block,
                 num_in_filter=last_c,
-                num_filters=c,
-                ifshortcut=ifshortcut,
-                ifse=ifse,
+                num_filters=out_channel,
+                ifshortcut=shortcut,
+                ifse=squeeze,
                 stride=1,
-                filter_size=k,
-                expansion_factor=t,
+                filter_size=filter_size,
+                expansion_factor=expansion,
                 name=name + '_' + str(i + 1))
         return last_residual_block