test_inference_model_io.py 17.0 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.

D
dzhwinter 已提交
15 16
import unittest

17
import os
18
import importlib
19
import tempfile
D
dzhwinter 已提交
20
import numpy as np
21
import paddle.fluid.core as core
22 23
import paddle.fluid as fluid
import warnings
24

25
import paddle
26 27 28
import paddle.fluid.executor as executor
import paddle.fluid.layers as layers
import paddle.fluid.optimizer as optimizer
T
tangwei12 已提交
29
from paddle.fluid.compiler import CompiledProgram
30
from paddle.fluid.framework import Program, program_guard
31 32 33 34 35
from paddle.fluid.io import (
    save_inference_model,
    load_inference_model,
    save_persistables,
)
36

37
paddle.enable_static()
38 39


40 41 42 43 44 45
class InferModel(object):
    def __init__(self, list):
        self.program = list[0]
        self.feed_var_names = list[1]
        self.fetch_vars = list[2]

46

47
class TestBook(unittest.TestCase):
48
    def test_fit_line_inference_model(self):
49 50 51
        root_path = tempfile.TemporaryDirectory()
        MODEL_DIR = os.path.join(root_path.name, "inference_model")
        UNI_MODEL_DIR = os.path.join(root_path.name, "inference_model1")
52 53 54

        init_program = Program()
        program = Program()
55 56 57 58 59 60 61 62

        with program_guard(program, init_program):
            x = layers.data(name='x', shape=[2], dtype='float32')
            y = layers.data(name='y', shape=[1], dtype='float32')

            y_predict = layers.fc(input=x, size=1, act=None)

            cost = layers.square_error_cost(input=y_predict, label=y)
63
            avg_cost = paddle.mean(cost)
64 65 66

            sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
            sgd_optimizer.minimize(avg_cost, init_program)
67 68 69 70 71 72

        place = core.CPUPlace()
        exe = executor.Executor(place)

        exe.run(init_program, feed={}, fetch_list=[])

73
        for i in range(100):
74 75 76
            tensor_x = np.array([[1, 1], [1, 2], [3, 4], [5, 2]]).astype(
                "float32"
            )
D
dzhwinter 已提交
77
            tensor_y = np.array([[-2], [-3], [-7], [-7]]).astype("float32")
78

79 80 81 82 83
            exe.run(
                program,
                feed={'x': tensor_x, 'y': tensor_y},
                fetch_list=[avg_cost],
            )
84

85
        # Separated model and unified model
86
        save_inference_model(MODEL_DIR, ["x", "y"], [avg_cost], exe, program)
87 88 89 90 91 92 93 94 95
        save_inference_model(
            UNI_MODEL_DIR,
            ["x", "y"],
            [avg_cost],
            exe,
            program,
            'model',
            'params',
        )
96
        main_program = program.clone()._prune_with_input(
97 98
            feeded_var_names=["x", "y"], targets=[avg_cost]
        )
99 100
        params_str = save_persistables(exe, None, main_program, None)

101 102 103
        expected = exe.run(
            program, feed={'x': tensor_x, 'y': tensor_y}, fetch_list=[avg_cost]
        )[0]
104

105
        importlib.reload(executor)  # reload to build a new scope
106

107
        model_0 = InferModel(load_inference_model(MODEL_DIR, exe))
108 109
        with open(os.path.join(UNI_MODEL_DIR, 'model'), "rb") as f:
            model_str = f.read()
110
        model_1 = InferModel(
111 112
            load_inference_model(None, exe, model_str, params_str)
        )
113 114

        for model in [model_0, model_1]:
115 116 117 118 119 120 121 122
            outs = exe.run(
                model.program,
                feed={
                    model.feed_var_names[0]: tensor_x,
                    model.feed_var_names[1]: tensor_y,
                },
                fetch_list=model.fetch_vars,
            )
123 124 125 126 127 128 129
            actual = outs[0]

            self.assertEqual(model.feed_var_names, ["x", "y"])
            self.assertEqual(len(model.fetch_vars), 1)
            print("fetch %s" % str(model.fetch_vars[0]))
            self.assertEqual(expected, actual)

130 131
        root_path.cleanup()

132 133 134 135 136 137 138 139
        self.assertRaises(
            ValueError,
            fluid.io.load_inference_model,
            None,
            exe,
            model_str,
            None,
        )
140 141


D
dzhwinter 已提交
142 143
class TestSaveInferenceModel(unittest.TestCase):
    def test_save_inference_model(self):
144 145
        root_path = tempfile.TemporaryDirectory()
        MODEL_DIR = os.path.join(root_path.name, "inference_model2")
D
dzhwinter 已提交
146 147 148 149 150 151 152 153 154 155 156
        init_program = Program()
        program = Program()

        # fake program without feed/fetch
        with program_guard(program, init_program):
            x = layers.data(name='x', shape=[2], dtype='float32')
            y = layers.data(name='y', shape=[1], dtype='float32')

            y_predict = layers.fc(input=x, size=1, act=None)

            cost = layers.square_error_cost(input=y_predict, label=y)
157
            avg_cost = paddle.mean(cost)
D
dzhwinter 已提交
158 159 160 161 162

        place = core.CPUPlace()
        exe = executor.Executor(place)
        exe.run(init_program, feed={}, fetch_list=[])

D
dzhwinter 已提交
163
        save_inference_model(MODEL_DIR, ["x", "y"], [avg_cost], exe, program)
164
        root_path.cleanup()
D
dzhwinter 已提交
165

166
    def test_save_inference_model_with_auc(self):
167 168
        root_path = tempfile.TemporaryDirectory()
        MODEL_DIR = os.path.join(root_path.name, "inference_model4")
169 170 171 172 173 174
        init_program = Program()
        program = Program()

        # fake program without feed/fetch
        with program_guard(program, init_program):
            x = layers.data(name='x', shape=[2], dtype='float32')
175
            y = layers.data(name='y', shape=[1], dtype='int32')
176 177
            predict = fluid.layers.fc(input=x, size=2, act='softmax')
            acc = fluid.layers.accuracy(input=predict, label=y)
178 179 180
            auc_var, batch_auc_var, auc_states = fluid.layers.auc(
                input=predict, label=y
            )
181
            cost = fluid.layers.cross_entropy(input=predict, label=y)
182
            avg_cost = paddle.mean(x=cost)
183 184 185 186 187 188

        place = core.CPUPlace()
        exe = executor.Executor(place)
        exe.run(init_program, feed={}, fetch_list=[])
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
189 190 191
            save_inference_model(
                MODEL_DIR, ["x", "y"], [avg_cost], exe, program
            )
192
            root_path.cleanup()
193 194 195 196
            expected_warn = "please ensure that you have set the auc states to zeros before saving inference model"
            self.assertTrue(len(w) > 0)
            self.assertTrue(expected_warn == str(w[0].message))

D
dzhwinter 已提交
197

T
tangwei12 已提交
198 199
class TestInstance(unittest.TestCase):
    def test_save_inference_model(self):
200 201
        root_path = tempfile.TemporaryDirectory()
        MODEL_DIR = os.path.join(root_path.name, "inference_model3")
T
tangwei12 已提交
202 203 204 205 206 207 208 209 210 211 212
        init_program = Program()
        program = Program()

        # fake program without feed/fetch
        with program_guard(program, init_program):
            x = layers.data(name='x', shape=[2], dtype='float32')
            y = layers.data(name='y', shape=[1], dtype='float32')

            y_predict = layers.fc(input=x, size=1, act=None)

            cost = layers.square_error_cost(input=y_predict, label=y)
213
            avg_cost = paddle.mean(cost)
T
tangwei12 已提交
214 215 216 217 218 219 220 221

        place = core.CPUPlace()
        exe = executor.Executor(place)
        exe.run(init_program, feed={}, fetch_list=[])

        # will print warning message

        cp_prog = CompiledProgram(program).with_data_parallel(
222 223
            loss_name=avg_cost.name
        )
T
tangwei12 已提交
224

C
chengduo 已提交
225
        save_inference_model(MODEL_DIR, ["x", "y"], [avg_cost], exe, cp_prog)
226 227 228 229 230
        self.assertRaises(
            TypeError,
            save_inference_model,
            [MODEL_DIR, ["x", "y"], [avg_cost], [], cp_prog],
        )
231
        root_path.cleanup()
T
tangwei12 已提交
232 233


234 235
class TestSaveInferenceModelNew(unittest.TestCase):
    def test_save_and_load_inference_model(self):
236 237
        root_path = tempfile.TemporaryDirectory()
        MODEL_DIR = os.path.join(root_path.name, "inference_model5")
238 239 240 241 242 243 244 245 246 247 248
        init_program = fluid.default_startup_program()
        program = fluid.default_main_program()

        # fake program without feed/fetch
        with program_guard(program, init_program):
            x = layers.data(name='x', shape=[2], dtype='float32')
            y = layers.data(name='y', shape=[1], dtype='float32')

            y_predict = layers.fc(input=x, size=1, act=None)

            cost = layers.square_error_cost(input=y_predict, label=y)
249
            avg_cost = paddle.mean(cost)
250 251 252 253 254 255 256 257 258 259

            sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
            sgd_optimizer.minimize(avg_cost, init_program)

        place = core.CPUPlace()
        exe = executor.Executor(place)
        exe.run(init_program, feed={}, fetch_list=[])

        tensor_x = np.array([[1, 1], [1, 2], [5, 2]]).astype("float32")
        tensor_y = np.array([[-2], [-3], [-7]]).astype("float32")
260
        for i in range(3):
261 262 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 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
            exe.run(
                program,
                feed={'x': tensor_x, 'y': tensor_y},
                fetch_list=[avg_cost],
            )

        self.assertRaises(
            ValueError,
            paddle.static.save_inference_model,
            None,
            ['x', 'y'],
            [avg_cost],
            exe,
        )
        self.assertRaises(
            ValueError,
            paddle.static.save_inference_model,
            MODEL_DIR + "/",
            [x, y],
            [avg_cost],
            exe,
        )
        self.assertRaises(
            ValueError,
            paddle.static.save_inference_model,
            MODEL_DIR,
            ['x', 'y'],
            [avg_cost],
            exe,
        )
        self.assertRaises(
            ValueError,
            paddle.static.save_inference_model,
            MODEL_DIR,
            'x',
            [avg_cost],
            exe,
        )
        self.assertRaises(
            ValueError,
            paddle.static.save_inference_model,
            MODEL_DIR,
            [x, y],
            ['avg_cost'],
            exe,
        )
        self.assertRaises(
            ValueError,
            paddle.static.save_inference_model,
            MODEL_DIR,
            [x, y],
            'avg_cost',
            exe,
        )
315 316 317

        model_path = MODEL_DIR + "_isdir.pdmodel"
        os.makedirs(model_path)
318 319 320 321 322 323 324 325
        self.assertRaises(
            ValueError,
            paddle.static.save_inference_model,
            MODEL_DIR + "_isdir",
            [x, y],
            [avg_cost],
            exe,
        )
326 327 328 329
        os.rmdir(model_path)

        params_path = MODEL_DIR + "_isdir.pdmodel"
        os.makedirs(params_path)
330 331 332 333 334 335 336 337
        self.assertRaises(
            ValueError,
            paddle.static.save_inference_model,
            MODEL_DIR + "_isdir",
            [x, y],
            [avg_cost],
            exe,
        )
338 339
        os.rmdir(params_path)

340 341 342
        paddle.static.io.save_inference_model(
            MODEL_DIR, [x, y], [avg_cost], exe
        )
343 344 345 346

        self.assertTrue(os.path.exists(MODEL_DIR + ".pdmodel"))
        self.assertTrue(os.path.exists(MODEL_DIR + ".pdiparams"))

347 348 349
        expected = exe.run(
            program, feed={'x': tensor_x, 'y': tensor_y}, fetch_list=[avg_cost]
        )[0]
350

351
        importlib.reload(executor)  # reload to build a new scope
352

353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
        self.assertRaises(
            ValueError, paddle.static.load_inference_model, None, exe
        )
        self.assertRaises(
            ValueError, paddle.static.load_inference_model, MODEL_DIR + "/", exe
        )
        self.assertRaises(
            ValueError, paddle.static.load_inference_model, [MODEL_DIR], exe
        )
        self.assertRaises(
            ValueError,
            paddle.static.load_inference_model,
            MODEL_DIR,
            exe,
            pserver_endpoints=None,
        )
        self.assertRaises(
            ValueError,
            paddle.static.load_inference_model,
            MODEL_DIR,
            exe,
            unsupported_param=None,
        )
        self.assertRaises(
            (TypeError, ValueError),
            paddle.static.load_inference_model,
            None,
            exe,
            model_filename="illegal",
            params_filename="illegal",
        )

        model = InferModel(
            paddle.static.io.load_inference_model(MODEL_DIR, exe)
        )
388
        root_path.cleanup()
389

390 391 392 393 394 395 396 397
        outs = exe.run(
            model.program,
            feed={
                model.feed_var_names[0]: tensor_x,
                model.feed_var_names[1]: tensor_y,
            },
            fetch_list=model.fetch_vars,
        )
398 399 400 401 402
        actual = outs[0]

        self.assertEqual(model.feed_var_names, ["x", "y"])
        self.assertEqual(len(model.fetch_vars), 1)
        self.assertEqual(expected, actual)
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
        # test save_to_file content type should be bytes
        self.assertRaises(ValueError, paddle.static.io.save_to_file, '', 123)
        # test _get_valid_program
        self.assertRaises(TypeError, paddle.static.io._get_valid_program, 0)
        p = Program()
        cp = CompiledProgram(p)
        paddle.static.io._get_valid_program(cp)
        self.assertTrue(paddle.static.io._get_valid_program(cp) is p)
        cp._program = None
        self.assertRaises(TypeError, paddle.static.io._get_valid_program, cp)

    def test_serialize_program_and_persistables(self):
        init_program = fluid.default_startup_program()
        program = fluid.default_main_program()

        # fake program without feed/fetch
        with program_guard(program, init_program):
            x = layers.data(name='x', shape=[2], dtype='float32')
            y = layers.data(name='y', shape=[1], dtype='float32')

            y_predict = layers.fc(input=x, size=1, act=None)

            cost = layers.square_error_cost(input=y_predict, label=y)
426
            avg_cost = paddle.mean(cost)
427 428 429 430 431 432 433 434 435 436

            sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
            sgd_optimizer.minimize(avg_cost, init_program)

        place = core.CPUPlace()
        exe = executor.Executor(place)
        exe.run(init_program, feed={}, fetch_list=[])

        tensor_x = np.array([[1, 1], [1, 2], [5, 2]]).astype("float32")
        tensor_y = np.array([[-2], [-3], [-7]]).astype("float32")
437
        for i in range(3):
438 439 440 441 442
            exe.run(
                program,
                feed={'x': tensor_x, 'y': tensor_y},
                fetch_list=[avg_cost],
            )
443

444 445 446 447 448 449 450 451 452
        # test if return type of serialize_program is bytes
        res1 = paddle.static.io.serialize_program([x, y], [avg_cost])
        self.assertTrue(isinstance(res1, bytes))
        # test if return type of serialize_persistables is bytes
        res2 = paddle.static.io.serialize_persistables([x, y], [avg_cost], exe)
        self.assertTrue(isinstance(res2, bytes))
        # test if variables in program is empty
        res = paddle.static.io._serialize_persistables(Program(), None)
        self.assertEqual(res, None)
453 454 455 456 457 458 459
        self.assertRaises(
            TypeError,
            paddle.static.io.deserialize_persistables,
            None,
            None,
            None,
        )
460

461 462 463 464 465 466 467 468 469 470 471 472
    def test_normalize_program(self):
        init_program = fluid.default_startup_program()
        program = fluid.default_main_program()

        # fake program without feed/fetch
        with program_guard(program, init_program):
            x = layers.data(name='x', shape=[2], dtype='float32')
            y = layers.data(name='y', shape=[1], dtype='float32')

            y_predict = layers.fc(input=x, size=1, act=None)

            cost = layers.square_error_cost(input=y_predict, label=y)
473
            avg_cost = paddle.mean(cost)
474 475 476 477 478 479 480 481 482 483

            sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
            sgd_optimizer.minimize(avg_cost, init_program)

        place = core.CPUPlace()
        exe = executor.Executor(place)
        exe.run(init_program, feed={}, fetch_list=[])

        tensor_x = np.array([[1, 1], [1, 2], [5, 2]]).astype("float32")
        tensor_y = np.array([[-2], [-3], [-7]]).astype("float32")
484
        for i in range(3):
485 486 487 488 489
            exe.run(
                program,
                feed={'x': tensor_x, 'y': tensor_y},
                fetch_list=[avg_cost],
            )
490 491 492 493 494

        # test if return type of serialize_program is bytes
        res = paddle.static.normalize_program(program, [x, y], [avg_cost])
        self.assertTrue(isinstance(res, Program))
        # test program type
495 496 497
        self.assertRaises(
            TypeError, paddle.static.normalize_program, None, [x, y], [avg_cost]
        )
498
        # test feed_vars type
499 500 501
        self.assertRaises(
            TypeError, paddle.static.normalize_program, program, 'x', [avg_cost]
        )
502
        # test fetch_vars type
503 504 505 506 507 508 509
        self.assertRaises(
            TypeError,
            paddle.static.normalize_program,
            program,
            [x, y],
            'avg_cost',
        )
510

511

512 513 514 515
class TestLoadInferenceModelError(unittest.TestCase):
    def test_load_model_not_exist(self):
        place = core.CPUPlace()
        exe = executor.Executor(place)
516 517 518
        self.assertRaises(
            ValueError, load_inference_model, './test_not_exist_dir', exe
        )
519 520


521 522
if __name__ == '__main__':
    unittest.main()