Update vgg and resnet via api v2

demo/image_classification/train_v2_resnet.py → demo/image_classification/api_v2_resnet.py

@@ -14,12 +14,7 @@
 
 import paddle.v2 as paddle
 
-
-def event_handler(event):
-    if isinstance(event, paddle.event.EndIteration):
-        if event.batch_id % 100 == 0:
-            print "Pass %d, Batch %d, Cost %f" % (event.pass_id, event.batch_id,
-                                                  event.cost)
+__all__ = ['resnet_cifar10']
 
 
 def conv_bn_layer(input,
@@ -43,7 +38,6 @@ def conv_bn_layer(input,
 
 def shortcut(ipt, n_in, n_out, stride):
     if n_in != n_out:
-        print("n_in != n_out")
         return conv_bn_layer(ipt, n_out, 1, stride, 0,
                              paddle.activation.Linear())
     else:
@@ -51,22 +45,13 @@ def shortcut(ipt, n_in, n_out, stride):
 
 
 def basicblock(ipt, ch_out, stride):
-    ch_in = ipt.num_filters
+    ch_in = ch_out * 2
     tmp = conv_bn_layer(ipt, ch_out, 3, stride, 1)
     tmp = conv_bn_layer(tmp, ch_out, 3, 1, 1, paddle.activation.Linear())
     short = shortcut(ipt, ch_in, ch_out, stride)
     return paddle.layer.addto(input=[tmp, short], act=paddle.activation.Relu())
 
 
-def bottleneck(ipt, ch_out, stride):
-    ch_in = ipt.num_filter
-    tmp = conv_bn_layer(ipt, ch_out, 1, stride, 0)
-    tmp = conv_bn_layer(tmp, ch_out, 3, 1, 1)
-    tmp = conv_bn_layer(tmp, ch_out * 4, 1, 1, 0, paddle.activation.Linear())
-    short = shortcut(ipt, ch_in, ch_out * 4, stride)
-    return paddle.layer.addto(input=[tmp, short], act=paddle.activation.Relu())
-
-
 def layer_warp(block_func, ipt, features, count, stride):
     tmp = block_func(ipt, features, stride)
     for i in range(1, count):
@@ -74,29 +59,6 @@ def layer_warp(block_func, ipt, features, count, stride):
     return tmp
 
 
-def resnet_imagenet(ipt, depth=50):
-    cfg = {
-        18: ([2, 2, 2, 1], basicblock),
-        34: ([3, 4, 6, 3], basicblock),
-        50: ([3, 4, 6, 3], bottleneck),
-        101: ([3, 4, 23, 3], bottleneck),
-        152: ([3, 8, 36, 3], bottleneck)
-    }
-    stages, block_func = cfg[depth]
-    tmp = conv_bn_layer(
-        ipt, ch_in=3, ch_out=64, filter_size=7, stride=2, padding=3)
-    tmp = paddle.layer.img_pool(input=tmp, pool_size=3, stride=2)
-    tmp = layer_warp(block_func, tmp, 64, stages[0], 1)
-    tmp = layer_warp(block_func, tmp, 128, stages[1], 2)
-    tmp = layer_warp(block_func, tmp, 256, stages[2], 2)
-    tmp = layer_warp(block_func, tmp, 512, stages[3], 2)
-    tmp = paddle.layer.img_pool(
-        input=tmp, pool_size=7, stride=1, pool_type=paddle.pooling.Avg())
-
-    tmp = paddle.layer.fc(input=tmp, size=1000, act=paddle.activation.Softmax())
-    return tmp
-
-
 def resnet_cifar10(ipt, depth=32):
     # depth should be one of 20, 32, 44, 56, 110, 1202
     assert (depth - 2) % 6 == 0
@@ -110,49 +72,3 @@ def resnet_cifar10(ipt, depth=32):
     pool = paddle.layer.img_pool(
         input=res3, pool_size=8, stride=1, pool_type=paddle.pooling.Avg())
     return pool
-
-
-def main():
-    datadim = 3 * 32 * 32
-    classdim = 10
-
-    paddle.init(use_gpu=False, trainer_count=1)
-
-    image = paddle.layer.data(
-        name="image", type=paddle.data_type.dense_vector(datadim))
-    net = resnet_cifar10(image, depth=32)
-    out = paddle.layer.fc(input=net,
-                          size=classdim,
-                          act=paddle.activation.Softmax())
-
-    lbl = paddle.layer.data(
-        name="label", type=paddle.data_type.integer_value(classdim))
-    cost = paddle.layer.classification_cost(input=out, label=lbl)
-
-    parameters = paddle.parameters.create(cost)
-
-    momentum_optimizer = paddle.optimizer.Momentum(
-        momentum=0.9,
-        regularization=paddle.optimizer.L2Regularization(rate=0.0002 * 128),
-        learning_rate=0.1 / 128.0,
-        learning_rate_decay_a=0.1,
-        learning_rate_decay_b=50000 * 100,
-        learning_rate_schedule='discexp',
-        batch_size=128)
-
-    trainer = paddle.trainer.SGD(update_equation=momentum_optimizer)
-    trainer.train(
-        reader=paddle.reader.batched(
-            paddle.reader.shuffle(
-                paddle.dataset.cifar.train10(), buf_size=3072),
-            batch_size=128),
-        cost=cost,
-        num_passes=1,
-        parameters=parameters,
-        event_handler=event_handler,
-        reader_dict={'image': 0,
-                     'label': 1}, )
-
-
-if __name__ == '__main__':
-    main()

demo/image_classification/train_v2_vgg.py → demo/image_classification/api_v2_train.py

@@ -10,9 +10,10 @@
 # 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.
+# limitations under the License
 
-import paddle.v2 as paddle
+from api_v2_vgg import resnet_cifar10
+from api_v2_resnet import vgg_bn_drop
 
 
 def event_handler(event):
@@ -22,46 +23,21 @@ def event_handler(event):
                                                   event.cost)
 
 
-def vgg_bn_drop(input):
-    def conv_block(ipt, num_filter, groups, dropouts, num_channels=None):
-        return paddle.layer.img_conv_group(
-            input=ipt,
-            num_channels=num_channels,
-            pool_size=2,
-            pool_stride=2,
-            conv_num_filter=[num_filter] * groups,
-            conv_filter_size=3,
-            conv_act=paddle.activation.Relu(),
-            conv_with_batchnorm=True,
-            conv_batchnorm_drop_rate=dropouts,
-            pool_type=paddle.pooling.Max())
-
-    conv1 = conv_block(input, 64, 2, [0.3, 0], 3)
-    conv2 = conv_block(conv1, 128, 2, [0.4, 0])
-    conv3 = conv_block(conv2, 256, 3, [0.4, 0.4, 0])
-    conv4 = conv_block(conv3, 512, 3, [0.4, 0.4, 0])
-    conv5 = conv_block(conv4, 512, 3, [0.4, 0.4, 0])
-
-    drop = paddle.layer.dropout(input=conv5, dropout_rate=0.5)
-    fc1 = paddle.layer.fc(input=drop, size=512, act=paddle.activation.Linear())
-    bn = paddle.layer.batch_norm(
-        input=fc1,
-        act=paddle.activation.Relu(),
-        layer_attr=ExtraAttr(drop_rate=0.5))
-    fc2 = paddle.layer.fc(input=bn, size=512, act=paddle.activation.Linear())
-    return fc2
-
-
 def main():
     datadim = 3 * 32 * 32
     classdim = 10
 
-    paddle.init(use_gpu=False, trainer_count=1)
+    paddle.init(use_gpu=True, trainer_count=1)
 
     image = paddle.layer.data(
         name="image", type=paddle.data_type.dense_vector(datadim))
+
+    # option 1. resnet
+    net = resnet_cifar10(image, depth=32)
+    # option 2. vgg
     # net = vgg_bn_drop(image)
-    out = paddle.layer.fc(input=image,
+
+    out = paddle.layer.fc(input=net,
                           size=classdim,
                           act=paddle.activation.Softmax())
 
@@ -70,27 +46,28 @@ def main():
     cost = paddle.layer.classification_cost(input=out, label=lbl)
 
     parameters = paddle.parameters.create(cost)
+
     momentum_optimizer = paddle.optimizer.Momentum(
         momentum=0.9,
-        regularization=paddle.optimizer.L2Regularization(rate=0.0005 * 128),
+        regularization=paddle.optimizer.L2Regularization(rate=0.0002 * 128),
         learning_rate=0.1 / 128.0,
         learning_rate_decay_a=0.1,
         learning_rate_decay_b=50000 * 100,
         learning_rate_schedule='discexp',
         batch_size=128)
 
-    trainer = paddle.trainer.SGD(update_equation=momentum_optimizer)
+    trainer = paddle.trainer.SGD(cost=cost,
+                                 parameters=parameters,
+                                 update_equation=momentum_optimizer)
     trainer.train(
         reader=paddle.reader.batched(
             paddle.reader.shuffle(
-                paddle.dataset.cifar.train10(), buf_size=3072),
+                paddle.dataset.cifar.train10(), buf_size=50000),
             batch_size=128),
-        cost=cost,
-        num_passes=1,
-        parameters=parameters,
+        num_passes=5,
         event_handler=event_handler,
         reader_dict={'image': 0,
-                     'label': 1}, )
+                     'label': 1})
 
 
 if __name__ == '__main__':

demo/image_classification/api_v2_vgg.py

+# Copyright (c) 2016 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 paddle.v2 as paddle
+
+__all__ = ['vgg_bn_drop']
+
+
+def vgg_bn_drop(input):
+    def conv_block(ipt, num_filter, groups, dropouts, num_channels=None):
+        return paddle.networks.img_conv_group(
+            input=ipt,
+            num_channels=num_channels,
+            pool_size=2,
+            pool_stride=2,
+            conv_num_filter=[num_filter] * groups,
+            conv_filter_size=3,
+            conv_act=paddle.activation.Relu(),
+            conv_with_batchnorm=True,
+            conv_batchnorm_drop_rate=dropouts,
+            pool_type=paddle.pooling.Max())
+
+    conv1 = conv_block(input, 64, 2, [0.3, 0], 3)
+    conv2 = conv_block(conv1, 128, 2, [0.4, 0])
+    conv3 = conv_block(conv2, 256, 3, [0.4, 0.4, 0])
+    conv4 = conv_block(conv3, 512, 3, [0.4, 0.4, 0])
+    conv5 = conv_block(conv4, 512, 3, [0.4, 0.4, 0])
+
+    drop = paddle.layer.dropout(input=conv5, dropout_rate=0.5)
+    fc1 = paddle.layer.fc(input=drop, size=512, act=paddle.activation.Linear())
+    bn = paddle.layer.batch_norm(
+        input=fc1,
+        act=paddle.activation.Relu(),
+        layer_attr=paddle.attr.Extra(drop_rate=0.5))
+    fc2 = paddle.layer.fc(input=bn, size=512, act=paddle.activation.Linear())
+    return fc2