diff --git a/PaddleSlim/__init__.py b/PaddleSlim/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/PaddleSlim/classification/__init__.py b/PaddleSlim/classification/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/PaddleSlim/classification/eval.py b/PaddleSlim/classification/eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..43e1065977666dce9c884fde78ca27364bc902c4
--- /dev/null
+++ b/PaddleSlim/classification/eval.py
@@ -0,0 +1,66 @@
+#copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
+#
+#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 numpy as np
+import argparse
+import functools
+
+import paddle
+import paddle.fluid as fluid
+import imagenet_reader as reader
+sys.path.append("../")
+from utility import add_arguments, print_arguments
+
+parser = argparse.ArgumentParser(description=__doc__)
+# yapf: disable
+add_arg = functools.partial(add_arguments, argparser=parser)
+add_arg('use_gpu', bool, False, "Whether to use GPU or not.")
+add_arg('model_path', str, "./pruning/checkpoints/resnet50/2/eval_model/", "Whether to use pretrained model.")
+# yapf: enable
+
+def eval(args):
+ # parameters from arguments
+
+ place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ val_program, feed_target_names, fetch_targets = fluid.io.load_inference_model(args.model_path,
+ exe,
+ model_filename="__model__",
+ params_filename="__params__")
+ val_reader = paddle.batch(reader.val(), batch_size=128)
+ feeder = fluid.DataFeeder(place=place, feed_list=feed_target_names, program=val_program)
+
+ results=[]
+ for batch_id, data in enumerate(val_reader()):
+
+ # top1_acc, top5_acc
+ result = exe.run(val_program,
+ feed=feeder.feed(data),
+ fetch_list=fetch_targets)
+ result = [np.mean(r) for r in result]
+ results.append(result)
+ result = np.mean(np.array(results), axis=0)
+ print("top1_acc/top5_acc= {}".format(result))
+ sys.stdout.flush()
+
+def main():
+ args = parser.parse_args()
+ print_arguments(args)
+ eval(args)
+
+if __name__ == '__main__':
+ main()
diff --git a/PaddleSlim/classification/imagenet_reader.py b/PaddleSlim/classification/imagenet_reader.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1f9909646f2e5c21203fe3c070156eb901ff0ca
--- /dev/null
+++ b/PaddleSlim/classification/imagenet_reader.py
@@ -0,0 +1,193 @@
+import os
+import math
+import random
+import functools
+import numpy as np
+import paddle
+from PIL import Image, ImageEnhance
+
+random.seed(0)
+np.random.seed(0)
+
+DATA_DIM = 224
+
+THREAD = 16
+BUF_SIZE = 10240
+
+DATA_DIR = '../data/ILSVRC2012'
+DATA_DIR = os.path.join(os.path.split(os.path.realpath(__file__))[0], DATA_DIR)
+
+
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+ percent = float(target_size) / min(img.size[0], img.size[1])
+ resized_width = int(round(img.size[0] * percent))
+ resized_height = int(round(img.size[1] * percent))
+ img = img.resize((resized_width, resized_height), Image.LANCZOS)
+ return img
+
+
+def crop_image(img, target_size, center):
+ width, height = img.size
+ size = target_size
+ if center == True:
+ w_start = (width - size) / 2
+ h_start = (height - size) / 2
+ else:
+ w_start = np.random.randint(0, width - size + 1)
+ h_start = np.random.randint(0, height - size + 1)
+ w_end = w_start + size
+ h_end = h_start + size
+ img = img.crop((w_start, h_start, w_end, h_end))
+ return img
+
+
+def random_crop(img, size, scale=[0.08, 1.0], ratio=[3. / 4., 4. / 3.]):
+ aspect_ratio = math.sqrt(np.random.uniform(*ratio))
+ w = 1. * aspect_ratio
+ h = 1. / aspect_ratio
+
+ bound = min((float(img.size[0]) / img.size[1]) / (w**2),
+ (float(img.size[1]) / img.size[0]) / (h**2))
+ scale_max = min(scale[1], bound)
+ scale_min = min(scale[0], bound)
+
+ target_area = img.size[0] * img.size[1] * np.random.uniform(scale_min,
+ scale_max)
+ target_size = math.sqrt(target_area)
+ w = int(target_size * w)
+ h = int(target_size * h)
+
+ i = np.random.randint(0, img.size[0] - w + 1)
+ j = np.random.randint(0, img.size[1] - h + 1)
+
+ img = img.crop((i, j, i + w, j + h))
+ img = img.resize((size, size), Image.LANCZOS)
+ return img
+
+
+def rotate_image(img):
+ angle = np.random.randint(-10, 11)
+ img = img.rotate(angle)
+ return img
+
+
+def distort_color(img):
+ def random_brightness(img, lower=0.5, upper=1.5):
+ e = np.random.uniform(lower, upper)
+ return ImageEnhance.Brightness(img).enhance(e)
+
+ def random_contrast(img, lower=0.5, upper=1.5):
+ e = np.random.uniform(lower, upper)
+ return ImageEnhance.Contrast(img).enhance(e)
+
+ def random_color(img, lower=0.5, upper=1.5):
+ e = np.random.uniform(lower, upper)
+ return ImageEnhance.Color(img).enhance(e)
+
+ ops = [random_brightness, random_contrast, random_color]
+ np.random.shuffle(ops)
+
+ img = ops[0](img)
+ img = ops[1](img)
+ img = ops[2](img)
+
+ return img
+
+
+def process_image(sample, mode, color_jitter, rotate):
+ img_path = sample[0]
+
+ img = Image.open(img_path)
+ if mode == 'train':
+ if rotate: img = rotate_image(img)
+ img = random_crop(img, DATA_DIM)
+ else:
+ img = resize_short(img, target_size=256)
+ img = crop_image(img, target_size=DATA_DIM, center=True)
+ if mode == 'train':
+ if color_jitter:
+ img = distort_color(img)
+ if np.random.randint(0, 2) == 1:
+ img = img.transpose(Image.FLIP_LEFT_RIGHT)
+
+ if img.mode != 'RGB':
+ img = img.convert('RGB')
+
+ img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+ img -= img_mean
+ img /= img_std
+
+ if mode == 'train' or mode == 'val':
+ return img, sample[1]
+ elif mode == 'test':
+ return [img]
+
+
+def _reader_creator(file_list,
+ mode,
+ shuffle=False,
+ color_jitter=False,
+ rotate=False,
+ data_dir=DATA_DIR,
+ batch_size=1):
+ def reader():
+ try:
+ with open(file_list) as flist:
+ full_lines = [line.strip() for line in flist]
+ if shuffle:
+ np.random.shuffle(full_lines)
+ if mode == 'train' and os.getenv('PADDLE_TRAINING_ROLE'):
+ # distributed mode if the env var `PADDLE_TRAINING_ROLE` exits
+ trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
+ trainer_count = int(os.getenv("PADDLE_TRAINERS", "1"))
+ per_node_lines = len(full_lines) // trainer_count
+ lines = full_lines[trainer_id * per_node_lines:(
+ trainer_id + 1) * per_node_lines]
+ print(
+ "read images from %d, length: %d, lines length: %d, total: %d"
+ % (trainer_id * per_node_lines, per_node_lines,
+ len(lines), len(full_lines)))
+ else:
+ lines = full_lines
+
+ for line in lines:
+ if mode == 'train' or mode == 'val':
+ img_path, label = line.split()
+ img_path = os.path.join(data_dir, img_path)
+ yield img_path, int(label)
+ elif mode == 'test':
+ img_path = os.path.join(data_dir, line)
+ yield [img_path]
+ except Exception as e:
+ print("Reader failed!\n{}".format(str(e)))
+ os._exit(1)
+
+ mapper = functools.partial(
+ process_image, mode=mode, color_jitter=color_jitter, rotate=rotate)
+
+ return paddle.reader.xmap_readers(mapper, reader, THREAD, BUF_SIZE)
+
+
+def train(data_dir=DATA_DIR):
+ file_list = os.path.join(data_dir, 'train_list.txt')
+ return _reader_creator(
+ file_list,
+ 'train',
+ shuffle=True,
+ color_jitter=False,
+ rotate=False,
+ data_dir=data_dir)
+
+
+def val(data_dir=DATA_DIR):
+ file_list = os.path.join(data_dir, 'val_list.txt')
+ return _reader_creator(file_list, 'val', shuffle=False, data_dir=data_dir)
+
+
+def test(data_dir=DATA_DIR):
+ file_list = os.path.join(data_dir, 'test_list.txt')
+ return _reader_creator(file_list, 'test', shuffle=False, data_dir=data_dir)
diff --git a/PaddleSlim/classification/infer.py b/PaddleSlim/classification/infer.py
new file mode 100644
index 0000000000000000000000000000000000000000..127b14048910bd1571029c91b347c1db6806a8cb
--- /dev/null
+++ b/PaddleSlim/classification/infer.py
@@ -0,0 +1,63 @@
+#copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
+#
+#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 numpy as np
+import argparse
+import functools
+
+import paddle
+import paddle.fluid as fluid
+import imagenet_reader as reader
+sys.path.append("..")
+from utility import add_arguments, print_arguments
+
+parser = argparse.ArgumentParser(description=__doc__)
+# yapf: disable
+add_arg = functools.partial(add_arguments, argparser=parser)
+add_arg('use_gpu', bool, False, "Whether to use GPU or not.")
+add_arg('model_path', str, "./pruning/checkpoints/resnet50/2/eval_model/", "Whether to use pretrained model.")
+# yapf: enable
+
+def infer(args):
+ # parameters from arguments
+
+ place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ test_program, feed_target_names, fetch_targets = fluid.io.load_inference_model(args.model_path,
+ exe,
+ model_filename="__model__.infer",
+ params_filename="__params__")
+ test_reader = paddle.batch(reader.test(), batch_size=1)
+ feeder = fluid.DataFeeder(place=place, feed_list=feed_target_names, program=test_program)
+
+ results=[]
+ for batch_id, data in enumerate(test_reader()):
+
+ # top1_acc, top5_acc
+ result = exe.run(test_program,
+ feed=feeder.feed(data),
+ fetch_list=fetch_targets)
+ print result
+ sys.stdout.flush()
+
+def main():
+ args = parser.parse_args()
+ print_arguments(args)
+ infer(args)
+
+if __name__ == '__main__':
+ main()
diff --git a/PaddleSlim/classification/models/__init__.py b/PaddleSlim/classification/models/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5b547393da6c5028970ebd499635a3afa4b3271
--- /dev/null
+++ b/PaddleSlim/classification/models/__init__.py
@@ -0,0 +1,5 @@
+from .mobilenet import MobileNet
+from .resnet import ResNet50
+from .mobilenet_v2 import MobileNetV2
+
+__all__=['MobileNet', 'ResNet50', 'MobileNetV2']
diff --git a/PaddleSlim/classification/models/mobilenet.py b/PaddleSlim/classification/models/mobilenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..921d6226ca2a65d5c9b57e27bf6607c7376c51f6
--- /dev/null
+++ b/PaddleSlim/classification/models/mobilenet.py
@@ -0,0 +1,197 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['MobileNet']
+
+train_parameters = {
+ "input_size": [3, 224, 224],
+ "input_mean": [0.485, 0.456, 0.406],
+ "input_std": [0.229, 0.224, 0.225],
+ "learning_strategy": {
+ "name": "piecewise_decay",
+ "batch_size": 256,
+ "epochs": [10, 16, 30],
+ "steps": [0.1, 0.01, 0.001, 0.0001]
+ }
+}
+
+
+class MobileNet():
+ def __init__(self):
+ self.params = train_parameters
+
+ def net(self, input, class_dim=1000, scale=1.0):
+ # conv1: 112x112
+ input = self.conv_bn_layer(
+ input,
+ filter_size=3,
+ channels=3,
+ num_filters=int(32 * scale),
+ stride=2,
+ padding=1,
+ name="conv1")
+
+ # 56x56
+ input = self.depthwise_separable(
+ input,
+ num_filters1=32,
+ num_filters2=64,
+ num_groups=32,
+ stride=1,
+ scale=scale,
+ name="conv2_1")
+
+ input = self.depthwise_separable(
+ input,
+ num_filters1=64,
+ num_filters2=128,
+ num_groups=64,
+ stride=2,
+ scale=scale,
+ name="conv2_2")
+
+ # 28x28
+ input = self.depthwise_separable(
+ input,
+ num_filters1=128,
+ num_filters2=128,
+ num_groups=128,
+ stride=1,
+ scale=scale,
+ name="conv3_1")
+
+ input = self.depthwise_separable(
+ input,
+ num_filters1=128,
+ num_filters2=256,
+ num_groups=128,
+ stride=2,
+ scale=scale,
+ name="conv3_2")
+
+ # 14x14
+ input = self.depthwise_separable(
+ input,
+ num_filters1=256,
+ num_filters2=256,
+ num_groups=256,
+ stride=1,
+ scale=scale,
+ name="conv4_1")
+
+ input = self.depthwise_separable(
+ input,
+ num_filters1=256,
+ num_filters2=512,
+ num_groups=256,
+ stride=2,
+ scale=scale,
+ name="conv4_2")
+
+ # 14x14
+ for i in range(5):
+ input = self.depthwise_separable(
+ input,
+ num_filters1=512,
+ num_filters2=512,
+ num_groups=512,
+ stride=1,
+ scale=scale,
+ name="conv5" + "_" + str(i + 1))
+ # 7x7
+ input = self.depthwise_separable(
+ input,
+ num_filters1=512,
+ num_filters2=1024,
+ num_groups=512,
+ stride=2,
+ scale=scale,
+ name="conv5_6")
+
+ input = self.depthwise_separable(
+ input,
+ num_filters1=1024,
+ num_filters2=1024,
+ num_groups=1024,
+ stride=1,
+ scale=scale,
+ name="conv6")
+
+ input = fluid.layers.pool2d(
+ input=input,
+ pool_size=0,
+ pool_stride=1,
+ pool_type='avg',
+ global_pooling=True)
+
+ output = fluid.layers.fc(input=input,
+ size=class_dim,
+ act='softmax',
+ param_attr=ParamAttr(
+ initializer=MSRA(), name="fc7_weights"),
+ bias_attr=ParamAttr(name="fc7_offset"))
+
+ return output
+
+ def conv_bn_layer(self,
+ input,
+ filter_size,
+ num_filters,
+ stride,
+ padding,
+ channels=None,
+ num_groups=1,
+ act='relu',
+ use_cudnn=True,
+ name=None):
+ conv = fluid.layers.conv2d(
+ input=input,
+ num_filters=num_filters,
+ filter_size=filter_size,
+ stride=stride,
+ padding=padding,
+ groups=num_groups,
+ act=None,
+ use_cudnn=use_cudnn,
+ param_attr=ParamAttr(
+ initializer=MSRA(), name=name + "_weights"),
+ bias_attr=False)
+ bn_name = name + "_bn"
+ return fluid.layers.batch_norm(
+ input=conv,
+ act=act,
+ param_attr=ParamAttr(name=bn_name + "_scale"),
+ bias_attr=ParamAttr(name=bn_name + "_offset"),
+ moving_mean_name=bn_name + '_mean',
+ moving_variance_name=bn_name + '_variance')
+
+ def depthwise_separable(self,
+ input,
+ num_filters1,
+ num_filters2,
+ num_groups,
+ stride,
+ scale,
+ name=None):
+ depthwise_conv = self.conv_bn_layer(
+ input=input,
+ filter_size=3,
+ num_filters=int(num_filters1 * scale),
+ stride=stride,
+ padding=1,
+ num_groups=int(num_groups * scale),
+ use_cudnn=False,
+ name=name + "_dw")
+
+ pointwise_conv = self.conv_bn_layer(
+ input=depthwise_conv,
+ filter_size=1,
+ num_filters=int(num_filters2 * scale),
+ stride=1,
+ padding=0,
+ name=name + "_sep")
+ return pointwise_conv
diff --git a/PaddleSlim/classification/models/mobilenet_v2.py b/PaddleSlim/classification/models/mobilenet_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..1855996ad20eb44ba656046db8a965b6da11784d
--- /dev/null
+++ b/PaddleSlim/classification/models/mobilenet_v2.py
@@ -0,0 +1,253 @@
+#copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['MobileNetV2', 'MobileNetV2_x0_25, ''MobileNetV2_x0_5', 'MobileNetV2_x1_0', 'MobileNetV2_x1_5', 'MobileNetV2_x2_0',
+ 'MobileNetV2_scale']
+
+train_parameters = {
+ "input_size": [3, 224, 224],
+ "input_mean": [0.485, 0.456, 0.406],
+ "input_std": [0.229, 0.224, 0.225],
+ "learning_strategy": {
+ "name": "piecewise_decay",
+ "batch_size": 256,
+ "epochs": [30, 60, 90],
+ "steps": [0.1, 0.01, 0.001, 0.0001]
+ }
+}
+
+
+class MobileNetV2():
+ def __init__(self, scale=1.0, change_depth=False):
+ self.params = train_parameters
+ self.scale = scale
+ self.change_depth=change_depth
+
+
+ def net(self, input, class_dim=1000):
+ scale = self.scale
+ change_depth = self.change_depth
+ #if change_depth is True, the new depth is 1.4 times as deep as before.
+ bottleneck_params_list = [
+ (1, 16, 1, 1),
+ (6, 24, 2, 2),
+ (6, 32, 3, 2),
+ (6, 64, 4, 2),
+ (6, 96, 3, 1),
+ (6, 160, 3, 2),
+ (6, 320, 1, 1),
+ ] if change_depth == False else [
+ (1, 16, 1, 1),
+ (6, 24, 2, 2),
+ (6, 32, 5, 2),
+ (6, 64, 7, 2),
+ (6, 96, 5, 1),
+ (6, 160, 3, 2),
+ (6, 320, 1, 1),
+ ]
+
+ #conv1
+ input = self.conv_bn_layer(
+ input,
+ num_filters=int(32 * scale),
+ filter_size=3,
+ stride=2,
+ padding=1,
+ if_act=True,
+ name='conv1_1')
+
+ # bottleneck sequences
+ i = 1
+ in_c = int(32 * scale)
+ for layer_setting in bottleneck_params_list:
+ t, c, n, s = layer_setting
+ i += 1
+ input = self.invresi_blocks(
+ input=input,
+ in_c=in_c,
+ t=t,
+ c=int(c * scale),
+ n=n,
+ s=s,
+ name='conv' + str(i))
+ in_c = int(c * scale)
+ #last_conv
+ input = self.conv_bn_layer(
+ input=input,
+ num_filters=int(1280 * scale) if scale > 1.0 else 1280,
+ filter_size=1,
+ stride=1,
+ padding=0,
+ if_act=True,
+ name='conv9')
+
+ input = fluid.layers.pool2d(
+ input=input,
+ pool_size=7,
+ pool_stride=1,
+ pool_type='avg',
+ global_pooling=True)
+
+ output = fluid.layers.fc(input=input,
+ size=class_dim,
+ act='softmax',
+ param_attr=ParamAttr(name='fc10_weights'),
+ bias_attr=ParamAttr(name='fc10_offset'))
+ return output
+
+ def conv_bn_layer(self,
+ input,
+ filter_size,
+ num_filters,
+ stride,
+ padding,
+ channels=None,
+ num_groups=1,
+ if_act=True,
+ name=None,
+ use_cudnn=True):
+ conv = fluid.layers.conv2d(
+ input=input,
+ num_filters=num_filters,
+ filter_size=filter_size,
+ stride=stride,
+ padding=padding,
+ groups=num_groups,
+ act=None,
+ use_cudnn=use_cudnn,
+ param_attr=ParamAttr(name=name + '_weights'),
+ bias_attr=False)
+ bn_name = name + '_bn'
+ bn = fluid.layers.batch_norm(
+ input=conv,
+ param_attr=ParamAttr(name=bn_name + "_scale"),
+ bias_attr=ParamAttr(name=bn_name + "_offset"),
+ moving_mean_name=bn_name + '_mean',
+ moving_variance_name=bn_name + '_variance')
+ if if_act:
+ return fluid.layers.relu6(bn)
+ else:
+ return bn
+
+ def shortcut(self, input, data_residual):
+ return fluid.layers.elementwise_add(input, data_residual)
+
+ def inverted_residual_unit(self,
+ input,
+ num_in_filter,
+ num_filters,
+ ifshortcut,
+ stride,
+ filter_size,
+ padding,
+ expansion_factor,
+ name=None):
+ num_expfilter = int(round(num_in_filter * expansion_factor))
+
+ channel_expand = self.conv_bn_layer(
+ input=input,
+ num_filters=num_expfilter,
+ filter_size=1,
+ stride=1,
+ padding=0,
+ num_groups=1,
+ if_act=True,
+ name=name + '_expand')
+
+ bottleneck_conv = self.conv_bn_layer(
+ input=channel_expand,
+ num_filters=num_expfilter,
+ filter_size=filter_size,
+ stride=stride,
+ padding=padding,
+ num_groups=num_expfilter,
+ if_act=True,
+ name=name + '_dwise',
+ use_cudnn=False)
+
+ linear_out = self.conv_bn_layer(
+ input=bottleneck_conv,
+ num_filters=num_filters,
+ filter_size=1,
+ stride=1,
+ padding=0,
+ num_groups=1,
+ if_act=False,
+ name=name + '_linear')
+ if ifshortcut:
+ out = self.shortcut(input=input, data_residual=linear_out)
+ return out
+ else:
+ return linear_out
+
+ def invresi_blocks(self, input, in_c, t, c, n, s, name=None):
+ first_block = self.inverted_residual_unit(
+ input=input,
+ num_in_filter=in_c,
+ num_filters=c,
+ ifshortcut=False,
+ stride=s,
+ filter_size=3,
+ padding=1,
+ expansion_factor=t,
+ name=name + '_1')
+
+ last_residual_block = first_block
+ last_c = c
+
+ for i in range(1, n):
+ last_residual_block = self.inverted_residual_unit(
+ input=last_residual_block,
+ num_in_filter=last_c,
+ num_filters=c,
+ ifshortcut=True,
+ stride=1,
+ filter_size=3,
+ padding=1,
+ expansion_factor=t,
+ name=name + '_' + str(i + 1))
+ return last_residual_block
+
+
+
+def MobileNetV2_x0_25():
+ model = MobileNetV2(scale=0.25)
+ return model
+
+def MobileNetV2_x0_5():
+ model = MobileNetV2(scale=0.5)
+ return model
+
+def MobileNetV2_x1_0():
+ model = MobileNetV2(scale=1.0)
+ return model
+
+def MobileNetV2_x1_5():
+ model = MobileNetV2(scale=1.5)
+ return model
+
+def MobileNetV2_x2_0():
+ model = MobileNetV2(scale=2.0)
+ return model
+
+def MobileNetV2_scale():
+ model = MobileNetV2(scale=1.2, change_depth=True)
+ return model
diff --git a/PaddleSlim/classification/models/resnet.py b/PaddleSlim/classification/models/resnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..a27bd52db3882c169778141a66b9752976e3a82d
--- /dev/null
+++ b/PaddleSlim/classification/models/resnet.py
@@ -0,0 +1,165 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle
+import paddle.fluid as fluid
+import math
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ["ResNet", "ResNet50", "ResNet101", "ResNet152"]
+
+train_parameters = {
+ "input_size": [3, 224, 224],
+ "input_mean": [0.485, 0.456, 0.406],
+ "input_std": [0.229, 0.224, 0.225],
+ "learning_strategy": {
+ "name": "piecewise_decay",
+ "batch_size": 256,
+ "epochs": [10, 16, 30],
+ "steps": [0.1, 0.01, 0.001, 0.0001]
+ }
+}
+
+
+class ResNet():
+ def __init__(self, layers=50):
+ self.params = train_parameters
+ self.layers = layers
+
+ def net(self, input, class_dim=1000, conv1_name='conv1', fc_name=None):
+ layers = self.layers
+ supported_layers = [50, 101, 152]
+ assert layers in supported_layers, \
+ "supported layers are {} but input layer is {}".format(supported_layers, layers)
+
+ if layers == 50:
+ depth = [3, 4, 6, 3]
+ elif layers == 101:
+ depth = [3, 4, 23, 3]
+ elif layers == 152:
+ depth = [3, 8, 36, 3]
+ num_filters = [64, 128, 256, 512]
+
+ # TODO(wanghaoshuang@baidu.com):
+ # fix name("conv1") conflict between student and teacher in distillation.
+ conv = self.conv_bn_layer(
+ input=input,
+ num_filters=64,
+ filter_size=7,
+ stride=2,
+ act='relu',
+ name=conv1_name)
+ conv = fluid.layers.pool2d(
+ input=conv,
+ pool_size=3,
+ pool_stride=2,
+ pool_padding=1,
+ pool_type='max')
+
+ for block in range(len(depth)):
+ for i in range(depth[block]):
+ if layers in [101, 152] and block == 2:
+ if i == 0:
+ conv_name = "res" + str(block + 2) + "a"
+ else:
+ conv_name = "res" + str(block + 2) + "b" + str(i)
+ else:
+ conv_name = "res" + str(block + 2) + chr(97 + i)
+ conv = self.bottleneck_block(
+ input=conv,
+ num_filters=num_filters[block],
+ stride=2 if i == 0 and block != 0 else 1,
+ name=conv_name)
+
+ pool = fluid.layers.pool2d(
+ input=conv, pool_size=7, pool_type='avg', global_pooling=True)
+ stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0)
+ out = fluid.layers.fc(input=pool,
+ size=class_dim,
+ act='softmax',
+ name=fc_name,
+ param_attr=fluid.param_attr.ParamAttr(
+ initializer=fluid.initializer.Uniform(-stdv,
+ stdv)))
+ return out
+
+ def conv_bn_layer(self,
+ input,
+ num_filters,
+ filter_size,
+ stride=1,
+ groups=1,
+ act=None,
+ name=None):
+ conv = fluid.layers.conv2d(
+ input=input,
+ num_filters=num_filters,
+ filter_size=filter_size,
+ stride=stride,
+ padding=(filter_size - 1) // 2,
+ groups=groups,
+ act=None,
+ param_attr=ParamAttr(name=name + "_weights"),
+ bias_attr=False,
+ name=name + '.conv2d.output.1')
+ if name == "conv1":
+ bn_name = "bn_" + name
+ else:
+ bn_name = "bn" + name[3:]
+ return fluid.layers.batch_norm(
+ input=conv,
+ act=act,
+ name=bn_name + '.output.1',
+ param_attr=ParamAttr(name=bn_name + '_scale'),
+ bias_attr=ParamAttr(bn_name + '_offset'),
+ moving_mean_name=bn_name + '_mean',
+ moving_variance_name=bn_name + '_variance', )
+
+ def shortcut(self, input, ch_out, stride, name):
+ ch_in = input.shape[1]
+ if ch_in != ch_out or stride != 1:
+ return self.conv_bn_layer(input, ch_out, 1, stride, name=name)
+ else:
+ return input
+
+ def bottleneck_block(self, input, num_filters, stride, name):
+ conv0 = self.conv_bn_layer(
+ input=input,
+ num_filters=num_filters,
+ filter_size=1,
+ act='relu',
+ name=name + "_branch2a")
+ conv1 = self.conv_bn_layer(
+ input=conv0,
+ num_filters=num_filters,
+ filter_size=3,
+ stride=stride,
+ act='relu',
+ name=name + "_branch2b")
+ conv2 = self.conv_bn_layer(
+ input=conv1,
+ num_filters=num_filters * 4,
+ filter_size=1,
+ act=None,
+ name=name + "_branch2c")
+
+ short = self.shortcut(
+ input, num_filters * 4, stride, name=name + "_branch1")
+
+ return fluid.layers.elementwise_add(
+ x=short, y=conv2, act='relu', name=name + ".add.output.5")
+
+
+def ResNet50():
+ model = ResNet(layers=50)
+ return model
+
+
+def ResNet101():
+ model = ResNet(layers=101)
+ return model
+
+
+def ResNet152():
+ model = ResNet(layers=152)
+ return model
diff --git a/PaddleSlim/classification/pruning/README.md b/PaddleSlim/classification/pruning/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ad92c3be4906f9f71922d7fd9239476fba133b5a
--- /dev/null
+++ b/PaddleSlim/classification/pruning/README.md
@@ -0,0 +1,155 @@
+>运行该示例前请安装Paddle1.6或更高版本
+
+# 分类模型卷积通道剪裁示例
+
+## 概述
+
+该示例使用PaddleSlim提供的[卷积通道剪裁压缩策略](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/tutorial.md#2-%E5%8D%B7%E7%A7%AF%E6%A0%B8%E5%89%AA%E8%A3%81%E5%8E%9F%E7%90%86)对分类模型进行压缩。
+在阅读该示例前，建议您先了解以下内容：
+
+- [分类模型的常规训练方法](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification)
+- [PaddleSlim使用文档](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md)
+
+
+## 配置文件说明
+
+关于配置文件如何编写您可以参考：
+
+- [PaddleSlim配置文件编写说明](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#122-%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E7%9A%84%E4%BD%BF%E7%94%A8)
+- [裁剪策略配置文件编写说明](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#22-%E6%A8%A1%E5%9E%8B%E9%80%9A%E9%81%93%E5%89%AA%E8%A3%81)
+
+其中，配置文件中的`pruned_params`需要根据当前模型的网络结构特点设置，它用来指定要裁剪的parameters.
+
+这里以MobileNetV2模型为例，MobileNetV2的主要结构为Inverted residuals, 如图1所示：
+
+
+
+
+图1
+
+
+PaddleSlim暂时无法对`depthwise convolution`直接进行剪裁， 因为`depthwise convolution`的`channel`的变化会同时影响到前后的卷积层。
+另外，`depthwise convolution`的参数（parameters）量占整个模型的比例并不高，所以，我们直接剪裁depthwise convolution的前后相邻的普通卷积层。
+通过以下命令观察目标卷积层的参数（parameters）的名称：
+
+```
+for param in fluid.default_main_program().global_block().all_parameters():
+ if 'weights' in param.name:
+ print param.name, param.shape
+```
+
+结果如下：
+
+```
+conv1_1_weights (32L, 3L, 3L, 3L)
+conv2_1_expand_weights (32L, 32L, 1L, 1L)
+conv2_1_dwise_weights (32L, 1L, 3L, 3L)
+conv2_1_linear_weights (16L, 32L, 1L, 1L)
+conv3_1_expand_weights (96L, 16L, 1L, 1L)
+conv3_1_dwise_weights (96L, 1L, 3L, 3L)
+conv3_1_linear_weights (24L, 96L, 1L, 1L)
+...
+conv8_1_expand_weights (960L, 160L, 1L, 1L)
+conv8_1_dwise_weights (960L, 1L, 3L, 3L)
+conv8_1_linear_weights (320L, 960L, 1L, 1L)
+conv9_weights (1280L, 320L, 1L, 1L)
+fc10_weights (1280L, 1000L)
+```
+
+观察可知，普通卷积的参数名称为`.*expand_weights`或`.*linear_weights`, 用以下正则表达式`.*[r|d]_weights`对其进行匹配。
+
+综上，我们将MobileNetV2配置文件中的`pruned_params`设置为`.*[r|d]_weights`。
+
+我们可以用上述操作观察MobileNetV1和ResNet50的参数名称规律，然后设置合适的正则表达式来剪裁合适的参数。
+
+
+## 训练
+
+根据[PaddleCV/image_classification/train.py](https://github.com/PaddlePaddle/models/blob/develop/PaddleCV/image_classification/train.py)编写压缩脚本compress.py。
+在该脚本中定义了Compressor对象，用于执行压缩任务。
+
+可以通过命令`python compress.py`用默认参数执行压缩任务，通过`python compress.py --help`查看可配置参数，简述如下：
+
+- use_gpu: 是否使用gpu。如果选择使用GPU，请确保当前环境和Paddle版本支持GPU。默认为True。
+- batch_size: 在剪裁之后，对模型进行fine-tune训练时用的batch size。
+- model: 要压缩的目标模型，该示例支持'MobileNetV1', 'MobileNetV2'和'ResNet50'。
+- pretrained_model: 预训练模型的路径，可以从[这里](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification#%E5%B7%B2%E5%8F%91%E5%B8%83%E6%A8%A1%E5%9E%8B%E5%8F%8A%E5%85%B6%E6%80%A7%E8%83%BD)下载。
+- config_file: 压缩策略的配置文件。
+
+您可以通过运行脚本`run.sh`运行改示例，请确保已正确下载[pretrained model](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification#%E5%B7%B2%E5%8F%91%E5%B8%83%E6%A8%A1%E5%9E%8B%E5%8F%8A%E5%85%B6%E6%80%A7%E8%83%BD)。
+
+
+### 保存断点（checkpoint）
+
+如果在配置文件中设置了`checkpoint_path`, 则在压缩任务执行过程中会自动保存断点，当任务异常中断时，
+重启任务会自动从`checkpoint_path`路径下按数字顺序加载最新的checkpoint文件。如果不想让重启的任务从断点恢复，
+需要修改配置文件中的`checkpoint_path`，或者将`checkpoint_path`路径下文件清空。
+
+>注意：配置文件中的信息不会保存在断点中，重启前对配置文件的修改将会生效。
+
+
+## 评估
+
+如果在配置文件中设置了`checkpoint_path`，则每个epoch会保存一个压缩后的用于评估的模型，
+该模型会保存在`${checkpoint_path}/${epoch_id}/eval_model/`路径下，包含`__model__`和`__params__`两个文件。
+其中，`__model__`用于保存模型结构信息，`__params__`用于保存参数（parameters）信息。
+
+如果不需要保存评估模型，可以在定义Compressor对象时，将`save_eval_model`选项设置为False（默认为True）。
+
+脚本PaddleSlim/classification/eval.py中为使用该模型在评估数据集上做评估的示例。
+
+## 预测
+
+如果在配置文件中设置了`checkpoint_path`，并且在定义Compressor对象时指定了`prune_infer_model`选项，则每个epoch都会
+保存一个`inference model`。该模型是通过删除eval_program中多余的operators而得到的。
+
+该模型会保存在`${checkpoint_path}/${epoch_id}/eval_model/`路径下，包含`__model__.infer`和`__params__`两个文件。
+其中，`__model__.infer`用于保存模型结构信息，`__params__`用于保存参数（parameters）信息。
+
+更多关于`prune_infer_model`选项的介绍，请参考：[Compressor介绍](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#121-%E5%A6%82%E4%BD%95%E6%94%B9%E5%86%99%E6%99%AE%E9%80%9A%E8%AE%AD%E7%BB%83%E8%84%9A%E6%9C%AC)
+
+### python预测
+
+在脚本PaddleSlim/classification/infer.py中展示了如何使用fluid python API加载使用预测模型进行预测。
+
+### PaddleLite
+
+该示例中产出的预测（inference）模型可以直接用PaddleLite进行加载使用。
+关于PaddleLite如何使用，请参考：[PaddleLite使用文档](https://github.com/PaddlePaddle/Paddle-Lite/wiki#%E4%BD%BF%E7%94%A8)
+
+## 示例结果
+
+### MobileNetV1
+
+| FLOPS |top1_acc/top5_acc| model_size |Paddle Fluid inference time(ms)| Paddle Lite inference time(ms)|
+|---|---|---|---|---|
+|baseline|70.99%/89.68% |- |- |-|
+|-10%|- |- |- |-|
+|-30%|- |- |- |-|
+|-50%|- |- |- |-|
+
+>训练超参：
+
+### MobileNetV2
+
+| FLOPS |top1_acc/top5_acc| model_size |Paddle Fluid inference time(ms)| Paddle Lite inference time(ms)|
+|---|---|---|---|---|
+|baseline|72.15%/90.65% |- |- |-|
+|-10%|- |- |- |-|
+|-30%|- |- |- |-|
+|-50%|- |- |- |-|
+
+>训练超参：
+
+### ResNet50
+
+| FLOPS |top1_acc/top5_acc| model_size |Paddle Fluid inference time(ms)| Paddle Lite inference time(ms)|
+|---|---|---|---|---|
+|baseline|76.50%/93.00% |- |- |-|
+|-10%|- |- |- |-|
+|-30%|- |- |- |-|
+|-50%|- |- |- |-|
+
+>训练超参：
+
+## FAQ
diff --git a/PaddleSlim/classification/pruning/__init__.py b/PaddleSlim/classification/pruning/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/PaddleSlim/classification/pruning/compress.py b/PaddleSlim/classification/pruning/compress.py
new file mode 100644
index 0000000000000000000000000000000000000000..b40d8a1c73d80588a063f27c6819043d543f14d7
--- /dev/null
+++ b/PaddleSlim/classification/pruning/compress.py
@@ -0,0 +1,103 @@
+import os
+import sys
+import logging
+import paddle
+import argparse
+import functools
+import paddle.fluid as fluid
+sys.path.append("..")
+import imagenet_reader as reader
+import models
+sys.path.append("../../")
+from utility import add_arguments, print_arguments
+
+from paddle.fluid.contrib.slim import Compressor
+
+logging.basicConfig(format='%(asctime)s-%(levelname)s: %(message)s')
+_logger = logging.getLogger(__name__)
+_logger.setLevel(logging.INFO)
+
+parser = argparse.ArgumentParser(description=__doc__)
+add_arg = functools.partial(add_arguments, argparser=parser)
+# yapf: disable
+add_arg('batch_size', int, 64*4, "Minibatch size.")
+add_arg('use_gpu', bool, True, "Whether to use GPU or not.")
+add_arg('model', str, None, "The target model.")
+add_arg('pretrained_model', str, None, "Whether to use pretrained model.")
+add_arg('config_file', str, None, "The config file for compression with yaml format.")
+# yapf: enable
+
+
+model_list = [m for m in dir(models) if "__" not in m]
+
+def compress(args):
+ class_dim=1000
+ image_shape="3,224,224"
+ image_shape = [int(m) for m in image_shape.split(",")]
+ assert args.model in model_list, "{} is not in lists: {}".format(args.model, model_list)
+ image = fluid.layers.data(name='image', shape=image_shape, dtype='float32')
+ label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+ # model definition
+ model = models.__dict__[args.model]()
+ out = model.net(input=image, class_dim=class_dim)
+ cost = fluid.layers.cross_entropy(input=out, label=label)
+ avg_cost = fluid.layers.mean(x=cost)
+ acc_top1 = fluid.layers.accuracy(input=out, label=label, k=1)
+ acc_top5 = fluid.layers.accuracy(input=out, label=label, k=5)
+ val_program = fluid.default_main_program().clone()
+# for param in fluid.default_main_program().global_block().all_parameters():
+# print param.name, param.shape
+# return
+ opt = fluid.optimizer.Momentum(
+ momentum=0.9,
+ learning_rate=fluid.layers.piecewise_decay(
+ boundaries=[5000 * 30, 5000 * 60, 5000 * 90],
+ values=[0.1, 0.01, 0.001, 0.0001]),
+ regularization=fluid.regularizer.L2Decay(4e-5))
+
+ place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ if args.pretrained_model:
+
+ def if_exist(var):
+ return os.path.exists(os.path.join(args.pretrained_model, var.name))
+
+ fluid.io.load_vars(exe, args.pretrained_model, predicate=if_exist)
+
+ val_reader = paddle.batch(reader.val(), batch_size=args.batch_size)
+ val_feed_list = [('image', image.name), ('label', label.name)]
+ val_fetch_list = [('acc_top1', acc_top1.name), ('acc_top5', acc_top5.name)]
+
+ train_reader = paddle.batch(
+ reader.train(), batch_size=args.batch_size, drop_last=True)
+ train_feed_list = [('image', image.name), ('label', label.name)]
+ train_fetch_list = [('loss', avg_cost.name)]
+
+ com_pass = Compressor(
+ place,
+ fluid.global_scope(),
+ fluid.default_main_program(),
+ train_reader=train_reader,
+ train_feed_list=train_feed_list,
+ train_fetch_list=train_fetch_list,
+ eval_program=val_program,
+ eval_reader=val_reader,
+ eval_feed_list=val_feed_list,
+ eval_fetch_list=val_fetch_list,
+ save_eval_model=True,
+ prune_infer_model=[[image.name], [out.name]],
+ train_optimizer=opt)
+ com_pass.config(args.config_file)
+ com_pass.run()
+
+
+def main():
+ args = parser.parse_args()
+ print_arguments(args)
+ compress(args)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/PaddleSlim/classification/pruning/configs/mobilenet_v1.yaml b/PaddleSlim/classification/pruning/configs/mobilenet_v1.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..de0b427f95d06d0f84ed958525e23ce82033174b
--- /dev/null
+++ b/PaddleSlim/classification/pruning/configs/mobilenet_v1.yaml
@@ -0,0 +1,20 @@
+version: 1.0
+pruners:
+ pruner_1:
+ class: 'StructurePruner'
+ pruning_axis:
+ '*': 0
+ criterions:
+ '*': 'l1_norm'
+strategies:
+ uniform_pruning_strategy:
+ class: 'UniformPruneStrategy'
+ pruner: 'pruner_1'
+ start_epoch: 0
+ target_ratio: 0.5
+ pruned_params: '.*_sep_weights'
+compressor:
+ epoch: 3
+ checkpoint_path: './checkpoints/mobilenet_v1/'
+ strategies:
+ - uniform_pruning_strategy
diff --git a/PaddleSlim/classification/pruning/configs/mobilenet_v2.yaml b/PaddleSlim/classification/pruning/configs/mobilenet_v2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4df7edccab91e5be99f75e48f20cadd953533c8a
--- /dev/null
+++ b/PaddleSlim/classification/pruning/configs/mobilenet_v2.yaml
@@ -0,0 +1,22 @@
+version: 1.0
+pruners:
+ pruner_1:
+ class: 'StructurePruner'
+ pruning_axis:
+ '*': 0
+ criterions:
+ '*': 'l1_norm'
+strategies:
+ uniform_pruning_strategy:
+ class: 'UniformPruneStrategy'
+ pruner: 'pruner_1'
+ start_epoch: 0
+ target_ratio: 0.5
+ pruned_params: '.*[r|d]_weights'
+# pruned_params: '.*linear_weights'
+# pruned_params: '.*expand_weights'
+compressor:
+ epoch: 2
+ checkpoint_path: './checkpoints/'
+ strategies:
+ - uniform_pruning_strategy
diff --git a/PaddleSlim/classification/pruning/configs/resnet50.yaml b/PaddleSlim/classification/pruning/configs/resnet50.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2519c4335611346e9f080b989ebcf503ca23b8b8
--- /dev/null
+++ b/PaddleSlim/classification/pruning/configs/resnet50.yaml
@@ -0,0 +1,20 @@
+version: 1.0
+pruners:
+ pruner_1:
+ class: 'StructurePruner'
+ pruning_axis:
+ '*': 0
+ criterions:
+ '*': 'l1_norm'
+strategies:
+ uniform_pruning_strategy:
+ class: 'UniformPruneStrategy'
+ pruner: 'pruner_1'
+ start_epoch: 0
+ target_ratio: 0.5
+ pruned_params: '.*branch.*_weights'
+compressor:
+ epoch: 4
+ checkpoint_path: './checkpoints/resnet50/'
+ strategies:
+ - uniform_pruning_strategy
diff --git a/PaddleSlim/classification/pruning/images/mobilenetv2.jpg b/PaddleSlim/classification/pruning/images/mobilenetv2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..c0dd3824dc77f8d3c87d719c13ceca16a3472e3c
Binary files /dev/null and b/PaddleSlim/classification/pruning/images/mobilenetv2.jpg differ
diff --git a/PaddleSlim/classification/pruning/run.sh b/PaddleSlim/classification/pruning/run.sh
new file mode 100644
index 0000000000000000000000000000000000000000..24cc4ece3f56fdb686a463acef814bc27acaa658
--- /dev/null
+++ b/PaddleSlim/classification/pruning/run.sh
@@ -0,0 +1,32 @@
+export CUDA_VISIBLE_DEVICES=0
+
+nohup python compress.py \
+--model "MobileNet" \
+--use_gpu 0 \
+--batch_size 1 \
+--pretrained_model ../pretrain/MobileNetV1_pretrained \
+--config_file "./configs/mobilenet_v1.yaml" \
+> mobilenet_v1.log 2>&1 &
+tailf mobilenet_v1.log
+
+# for compression of mobilenet_v2
+#nohup python compress.py \
+#--model "MobileNetV2" \
+#--use_gpu 0 \
+#--batch_size 1 \
+#--pretrained_model ../pretrain/MobileNetV2_pretrained \
+#--config_file "./configs/mobilenet_v2.yaml" \
+#> mobilenet_v2.log 2>&1 &
+#tailf mobilenet_v2.log
+
+
+# for compression of resnet50
+#python compress.py \
+#--model "ResNet50" \
+#--use_gpu 0 \
+#--batch_size 1 \
+#--pretrained_model ../pretrain/ResNet50_pretrained \
+#--config_file "./configs/resnet50.yaml" \
+#> resnet50.log 2>&1 &
+#tailf resnet50.log
+