test_image_classification.py 10.8 KB
Newer Older
1
#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
D
dzhwinter 已提交
2
#
D
dzhwinter 已提交
3 4 5
# 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
D
dzhwinter 已提交
6
#
D
dzhwinter 已提交
7
#     http://www.apache.org/licenses/LICENSE-2.0
D
dzhwinter 已提交
8
#
D
dzhwinter 已提交
9 10 11 12 13 14
# 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.

15 16
from __future__ import print_function

17
import paddle
18
import paddle.fluid as fluid
19
import contextlib
20 21
import math
import sys
22 23
import numpy
import unittest
24
import os
25
import numpy as np
26 27


28
def resnet_cifar10(input, depth=32):
29 30 31 32 33 34 35
    def conv_bn_layer(input,
                      ch_out,
                      filter_size,
                      stride,
                      padding,
                      act='relu',
                      bias_attr=False):
36
        tmp = fluid.layers.conv2d(
Q
Qiao Longfei 已提交
37 38 39 40 41 42
            input=input,
            filter_size=filter_size,
            num_filters=ch_out,
            stride=stride,
            padding=padding,
            act=None,
43
            bias_attr=bias_attr)
44
        return fluid.layers.batch_norm(input=tmp, act=act)
Q
Qiao Longfei 已提交
45

46
    def shortcut(input, ch_in, ch_out, stride):
Q
Qiao Longfei 已提交
47
        if ch_in != ch_out:
48
            return conv_bn_layer(input, ch_out, 1, stride, 0, None)
Q
Qiao Longfei 已提交
49 50 51
        else:
            return input

52 53
    def basicblock(input, ch_in, ch_out, stride):
        tmp = conv_bn_layer(input, ch_out, 3, stride, 1)
54
        tmp = conv_bn_layer(tmp, ch_out, 3, 1, 1, act=None, bias_attr=True)
55
        short = shortcut(input, ch_in, ch_out, stride)
56
        return fluid.layers.elementwise_add(x=tmp, y=short, act='relu')
Q
Qiao Longfei 已提交
57

58 59
    def layer_warp(block_func, input, ch_in, ch_out, count, stride):
        tmp = block_func(input, ch_in, ch_out, stride)
Q
Qiao Longfei 已提交
60
        for i in range(1, count):
61
            tmp = block_func(tmp, ch_out, ch_out, 1)
Q
Qiao Longfei 已提交
62 63 64
        return tmp

    assert (depth - 2) % 6 == 0
M
minqiyang 已提交
65
    n = (depth - 2) // 6
Q
Qiao Longfei 已提交
66
    conv1 = conv_bn_layer(
67 68 69 70
        input=input, ch_out=16, filter_size=3, stride=1, padding=1)
    res1 = layer_warp(basicblock, conv1, 16, 16, n, 1)
    res2 = layer_warp(basicblock, res1, 16, 32, n, 2)
    res3 = layer_warp(basicblock, res2, 32, 64, n, 2)
71
    pool = fluid.layers.pool2d(
72
        input=res3, pool_size=8, pool_type='avg', pool_stride=1)
Q
Qiao Longfei 已提交
73 74 75
    return pool


76
def vgg16_bn_drop(input):
77
    def conv_block(input, num_filter, groups, dropouts):
78
        return fluid.nets.img_conv_group(
79 80 81 82 83 84 85 86
            input=input,
            pool_size=2,
            pool_stride=2,
            conv_num_filter=[num_filter] * groups,
            conv_filter_size=3,
            conv_act='relu',
            conv_with_batchnorm=True,
            conv_batchnorm_drop_rate=dropouts,
87
            pool_type='max')
88

89 90 91 92 93
    conv1 = conv_block(input, 64, 2, [0.3, 0])
    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])
94

95
    drop = fluid.layers.dropout(x=conv5, dropout_prob=0.5)
96
    fc1 = fluid.layers.fc(input=drop, size=4096, act=None)
97
    bn = fluid.layers.batch_norm(input=fc1, act='relu')
98
    drop2 = fluid.layers.dropout(x=bn, dropout_prob=0.5)
99
    fc2 = fluid.layers.fc(input=drop2, size=4096, act=None)
100 101 102
    return fc2


103
def train(net_type, use_cuda, save_dirname, is_local):
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
    classdim = 10
    data_shape = [3, 32, 32]

    images = fluid.layers.data(name='pixel', shape=data_shape, dtype='float32')
    label = fluid.layers.data(name='label', shape=[1], dtype='int64')

    if net_type == "vgg":
        print("train vgg net")
        net = vgg16_bn_drop(images)
    elif net_type == "resnet":
        print("train resnet")
        net = resnet_cifar10(images, 32)
    else:
        raise ValueError("%s network is not supported" % net_type)

    predict = fluid.layers.fc(input=net, size=classdim, act='softmax')
    cost = fluid.layers.cross_entropy(input=predict, label=label)
121
    avg_cost = fluid.layers.mean(cost)
122 123
    acc = fluid.layers.accuracy(input=predict, label=label)

124
    # Test program
125
    test_program = fluid.default_main_program().clone(for_test=True)
126 127

    optimizer = fluid.optimizer.Adam(learning_rate=0.001)
W
Wu Yi 已提交
128
    optimizer.minimize(avg_cost)
129 130 131 132 133 134 135 136 137

    BATCH_SIZE = 128
    PASS_NUM = 1

    train_reader = paddle.batch(
        paddle.reader.shuffle(
            paddle.dataset.cifar.train10(), buf_size=128 * 10),
        batch_size=BATCH_SIZE)

138 139 140
    test_reader = paddle.batch(
        paddle.dataset.cifar.test10(), batch_size=BATCH_SIZE)

141 142 143
    place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
    exe = fluid.Executor(place)
    feeder = fluid.DataFeeder(place=place, feed_list=[images, label])
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167

    def train_loop(main_program):
        exe.run(fluid.default_startup_program())
        loss = 0.0
        for pass_id in range(PASS_NUM):
            for batch_id, data in enumerate(train_reader()):
                exe.run(main_program, feed=feeder.feed(data))

                if (batch_id % 10) == 0:
                    acc_list = []
                    avg_loss_list = []
                    for tid, test_data in enumerate(test_reader()):
                        loss_t, acc_t = exe.run(program=test_program,
                                                feed=feeder.feed(test_data),
                                                fetch_list=[avg_cost, acc])
                        if math.isnan(float(loss_t)):
                            sys.exit("got NaN loss, training failed.")
                        acc_list.append(float(acc_t))
                        avg_loss_list.append(float(loss_t))
                        break  # Use 1 segment for speeding up CI

                    acc_value = numpy.array(acc_list).mean()
                    avg_loss_value = numpy.array(avg_loss_list).mean()

168
                    print(
169 170
                        'PassID {0:1}, BatchID {1:04}, Test Loss {2:2.2}, Acc {3:2.2}'.
                        format(pass_id, batch_id + 1,
171
                               float(avg_loss_value), float(acc_value)))
172 173 174 175 176 177 178 179 180

                    if acc_value > 0.01:  # Low threshold for speeding up CI
                        fluid.io.save_inference_model(save_dirname, ["pixel"],
                                                      [predict], exe)
                        return

    if is_local:
        train_loop(fluid.default_main_program())
    else:
181 182
        port = os.getenv("PADDLE_PSERVER_PORT", "6174")
        pserver_ips = os.getenv("PADDLE_PSERVER_IPS")  # ip,ip...
183 184 185 186
        eplist = []
        for ip in pserver_ips.split(","):
            eplist.append(':'.join([ip, port]))
        pserver_endpoints = ",".join(eplist)  # ip:port,ip:port...
187
        trainers = int(os.getenv("PADDLE_TRAINERS"))
188
        current_endpoint = os.getenv("POD_IP") + ":" + port
189 190
        trainer_id = int(os.getenv("PADDLE_TRAINER_ID"))
        training_role = os.getenv("PADDLE_TRAINING_ROLE", "TRAINER")
191
        t = fluid.DistributeTranspiler()
192
        t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers)
193 194 195 196 197 198 199 200
        if training_role == "PSERVER":
            pserver_prog = t.get_pserver_program(current_endpoint)
            pserver_startup = t.get_startup_program(current_endpoint,
                                                    pserver_prog)
            exe.run(pserver_startup)
            exe.run(pserver_prog)
        elif training_role == "TRAINER":
            train_loop(t.get_trainer_program())
201 202 203 204 205 206 207 208 209


def infer(use_cuda, save_dirname=None):
    if save_dirname is None:
        return

    place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
    exe = fluid.Executor(place)

210 211 212 213 214 215 216 217 218 219 220 221 222 223
    inference_scope = fluid.core.Scope()
    with fluid.scope_guard(inference_scope):
        # Use fluid.io.load_inference_model to obtain the inference program desc,
        # the feed_target_names (the names of variables that will be feeded
        # data using feed operators), and the fetch_targets (variables that
        # we want to obtain data from using fetch operators).
        [inference_program, feed_target_names,
         fetch_targets] = fluid.io.load_inference_model(save_dirname, exe)

        # The input's dimension of conv should be 4-D or 5-D.
        # Use normilized image pixels as input data, which should be in the range [0, 1.0].
        batch_size = 1
        tensor_img = numpy.random.rand(batch_size, 3, 32, 32).astype("float32")

L
Luo Tao 已提交
224 225 226
        # Use inference_transpiler to speedup
        inference_transpiler_program = inference_program.clone()
        t = fluid.InferenceTranspiler()
227
        t.transpile(inference_transpiler_program, place)
L
Luo Tao 已提交
228

229 230 231 232 233
        # Construct feed as a dictionary of {feed_target_name: feed_target_data}
        # and results will contain a list of data corresponding to fetch_targets.
        results = exe.run(inference_program,
                          feed={feed_target_names[0]: tensor_img},
                          fetch_list=fetch_targets)
234 235 236 237 238 239 240

        transpiler_results = exe.run(inference_transpiler_program,
                                     feed={feed_target_names[0]: tensor_img},
                                     fetch_list=fetch_targets)

        assert len(results[0]) == len(transpiler_results[0])
        for i in range(len(results[0])):
241
            np.testing.assert_almost_equal(
242
                results[0][i], transpiler_results[0][i], decimal=5)
243

244
        print("infer results: ", results[0])
245

246 247 248 249
        fluid.io.save_inference_model(save_dirname, feed_target_names,
                                      fetch_targets, exe,
                                      inference_transpiler_program)

250

251
def main(net_type, use_cuda, is_local=True):
252 253 254 255 256 257
    if use_cuda and not fluid.core.is_compiled_with_cuda():
        return

    # Directory for saving the trained model
    save_dirname = "image_classification_" + net_type + ".inference.model"

258
    train(net_type, use_cuda, save_dirname, is_local)
259 260 261 262

    # There is bug in fluid.InferenceTranspiler for VGG.
    if net_type == "resnet":
        infer(use_cuda, save_dirname)
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293


class TestImageClassification(unittest.TestCase):
    def test_vgg_cuda(self):
        with self.scope_prog_guard():
            main('vgg', use_cuda=True)

    def test_resnet_cuda(self):
        with self.scope_prog_guard():
            main('resnet', use_cuda=True)

    def test_vgg_cpu(self):
        with self.scope_prog_guard():
            main('vgg', use_cuda=False)

    def test_resnet_cpu(self):
        with self.scope_prog_guard():
            main('resnet', use_cuda=False)

    @contextlib.contextmanager
    def scope_prog_guard(self):
        prog = fluid.Program()
        startup_prog = fluid.Program()
        scope = fluid.core.Scope()
        with fluid.scope_guard(scope):
            with fluid.program_guard(prog, startup_prog):
                yield


if __name__ == '__main__':
    unittest.main()
反馈
建议
客服 返回
顶部