move files

.gitignore

@@ -2,7 +2,6 @@ __pycache__/
 *.pyc
 *.sw*
 */workerlog*
-dataset/
 checkpoints/
 output/
 pretrained/

ppcls/__init__.py

@@ -14,7 +14,7 @@
 
 from . import optimizer
 
-from .modeling import *
+from .arch import *
 from .optimizer import *
 from .data import *
 from .utils import *

ppcls/modeling/__init__.py → ppcls/arch/__init__.py

@@ -12,9 +12,8 @@
 #See the License for the specific language governing permissions and
 #limitations under the License.
 
-from . import architectures
-from . import loss
+from . import backbone
 
-from .architectures import *
+from .backbone import *
 from .loss import *
 from .utils import *

ppcls/arch/backbone/base/theseus_layer.py

+from abc import ABC
+from paddle import nn
+import re
+
+
+class Identity(nn.Layer):
+    def __init__(self):
+        super(Identity, self).__init__()
+
+    def forward(self, inputs):
+        return inputs
+
+
+class TheseusLayer(nn.Layer, ABC):
+    def __init__(self, *args, return_patterns=None, stop_layer=None, **kwargs):
+        super(TheseusLayer, self).__init__()
+        self.res_dict = None
+        self.register_forward_post_hook(self._disconnect_res_dict_hook)
+        if return_patterns is not None or stop_layer is not None:
+            self._update_sub(return_patterns, stop_layer)
+
+    def forward(self, *input, res_dict=None, **kwargs):
+        if res_dict is not None:
+            self.res_dict = res_dict
+
+    def _update_sub(self, return_layers, stop_layer):
+        after_stop = False
+        for layer_i in self._sub_layers:
+            layer_name = self._sub_layers[layer_i].full_name()
+            if stop_layer is not None and layer_name == stop_layer:
+                after_stop = True
+            if after_stop:
+                self._sub_layers[layer_i] = Identity()
+            for return_pattern in return_layers:
+                if return_layers is not None and re.match(return_pattern, layer_name):
+                    self._sub_layers[layer_i].register_forward_post_hook(self._save_sub_res_hook)
+
+    def _save_sub_res_hook(self, layer, input, output):
+        self.res_dict[layer.full_name()] = output
+
+    def _disconnect_res_dict_hook(self, input, output):
+        self.res_dict = None
+
+    def replace_sub(self, layer_name_pattern, replace_function, recursive=True):
+        for layer_i in self._sub_layers:
+            layer_name = self._sub_layers[layer_i].full_name()
+            if re.match(layer_name_pattern, layer_name):
+                self._sub_layers[layer_i] = replace_function(self._sub_layers[layer_i])
+            if recursive and isinstance(self._sub_layers[layer_i], TheseusLayer):
+                self._sub_layers[layer_i].replace_sub(layer_name_pattern, replace_function, recursive)
+
+    '''
+    example of replace function:
+    def replace_conv(origin_conv: nn.Conv2D):
+        new_conv = nn.Conv2D(
+            in_channels=origin_conv._in_channels,
+            out_channels=origin_conv._out_channels,
+            kernel_size=origin_conv._kernel_size,
+            stride=2
+        )
+        return new_conv
+
+        '''
\ No newline at end of file

ppcls/modeling/utils.py → ppcls/arch/utils.py

@@ -16,7 +16,7 @@ import six
 import types
 from difflib import SequenceMatcher
 
-from . import architectures
+from . import backbone
 
 
 def get_architectures():
@@ -24,15 +24,15 @@ def get_architectures():
     get all of model architectures
     """
     names = []
-    for k, v in architectures.__dict__.items():
+    for k, v in backbone.__dict__.items():
         if isinstance(v, (types.FunctionType, six.class_types)):
             names.append(k)
     return names
 
 
 def get_blacklist_model_in_static_mode():
-    from ppcls.modeling.architectures import distilled_vision_transformer
-    from ppcls.modeling.architectures import vision_transformer
+    from ppcls.arch.backbone import distilled_vision_transformer
+    from ppcls.arch.backbone import vision_transformer
     blacklist = distilled_vision_transformer.__all__ + vision_transformer.__all__
     return blacklist
 

ppcls/data/dataset/flowers102/generate_flowers102_list.py

+"""
+.mat files data format
+imagelabel.mat
+jpg_name   1     2     3 ... 
+label      32    12    66 ... 
+
+setid.mat
+jpg_name(10 records in a class)  24 6 100 65 32 ...
+label                            4 ...
+"""
+"""
+Usage: 
+    python generate_flower_list.py prefix_folder mode
+    python generate_flower_list.py jpg train > train_list.txt
+    python generate_flower_list.py jpg valid > val_list.txt
+"""
+
+import scipy.io
+import numpy as np
+import os
+import sys
+
+data_path = sys.argv[1]
+imagelabels_path = './imagelabels.mat'
+setid_path = './setid.mat'
+
+labels = scipy.io.loadmat(imagelabels_path)
+labels = np.array(labels['labels'][0])
+setid = scipy.io.loadmat(setid_path)
+
+d = {}
+d['train'] = np.array(setid['trnid'][0])
+d['valid'] = np.array(setid['valid'][0])
+d['test'] = np.array(setid['tstid'][0])
+
+for id in d[sys.argv[2]]:
+   message = str(data_path) + "/image_" + str(id).zfill(5) + ".jpg " + str(labels[id - 1] - 1)
+   print(message)

ppcls/utils/check.py

@@ -22,9 +22,9 @@ import sys
 import paddle
 from paddle import is_compiled_with_cuda
 
-from ppcls.modeling import get_architectures
-from ppcls.modeling import similar_architectures
-from ppcls.modeling import get_blacklist_model_in_static_mode
+from ppcls.arch import get_architectures
+from ppcls.arch import similar_architectures
+from ppcls.arch import get_blacklist_model_in_static_mode
 from ppcls.utils import logger
 
 

ppcls/utils/model_zoo.py

@@ -23,7 +23,7 @@ import tarfile
 import tqdm
 import zipfile
 
-from ppcls.modeling import similar_architectures
+from ppcls.arch import similar_architectures
 from ppcls.utils import logger
 
 __all__ = ['get']