test_unsqueeze_op.py 10.3 KB
Newer Older
1
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6 7 8 9 10 11 12 13 14
#
# 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.

15
from __future__ import print_function
16
import unittest
17

18
import numpy as np
19

20 21
import paddle
import paddle.fluid as fluid
22 23
from op_test import OpTest, convert_float_to_uint16
import paddle.fluid.core as core
24

25
paddle.enable_static()
26 27 28


# Correct: General.
29
class TestUnsqueezeOp(OpTest):
30
    def setUp(self):
31
        self.init_test_case()
32
        self.op_type = "unsqueeze"
33
        self.inputs = {"X": np.random.random(self.ori_shape).astype("float64")}
C
chenweihang 已提交
34
        self.init_attrs()
35
        self.outputs = {"Out": self.inputs["X"].reshape(self.new_shape)}
36 37

    def test_check_output(self):
38
        self.check_output()
39 40 41 42

    def test_check_grad(self):
        self.check_grad(["X"], "Out")

43
    def init_test_case(self):
Z
zhupengyang 已提交
44
        self.ori_shape = (3, 40)
45
        self.axes = (1, 2)
Z
zhupengyang 已提交
46
        self.new_shape = (3, 1, 1, 40)
47

C
chenweihang 已提交
48
    def init_attrs(self):
49
        self.attrs = {"axes": self.axes}
C
chenweihang 已提交
50

51

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
class TestUnsqueezeBF16Op(OpTest):
    def setUp(self):
        self.init_test_case()
        self.op_type = "unsqueeze"
        self.dtype = np.uint16
        x = np.random.random(self.ori_shape).astype("float32")
        out = x.reshape(self.new_shape)
        self.inputs = {"X": convert_float_to_uint16(x)}
        self.init_attrs()
        self.outputs = {"Out": convert_float_to_uint16(out)}

    def test_check_output(self):
        self.check_output()

    def test_check_grad(self):
        self.check_grad(["X"], "Out")

    def init_test_case(self):
        self.ori_shape = (3, 40)
        self.axes = (1, 2)
        self.new_shape = (3, 1, 1, 40)

    def init_attrs(self):
        self.attrs = {"axes": self.axes}


78 79 80
# Correct: Single input index.
class TestUnsqueezeOp1(TestUnsqueezeOp):
    def init_test_case(self):
Z
zhupengyang 已提交
81
        self.ori_shape = (20, 5)
82
        self.axes = (-1, )
Z
zhupengyang 已提交
83
        self.new_shape = (20, 5, 1)
84 85 86


# Correct: Mixed input axis.
87 88
class TestUnsqueezeOp2(TestUnsqueezeOp):
    def init_test_case(self):
Z
zhupengyang 已提交
89
        self.ori_shape = (20, 5)
90
        self.axes = (0, -1)
Z
zhupengyang 已提交
91
        self.new_shape = (1, 20, 5, 1)
92 93


94
# Correct: There is duplicated axis.
95 96
class TestUnsqueezeOp3(TestUnsqueezeOp):
    def init_test_case(self):
Z
zhupengyang 已提交
97
        self.ori_shape = (10, 2, 5)
98
        self.axes = (0, 3, 3)
Z
zhupengyang 已提交
99
        self.new_shape = (1, 10, 2, 1, 1, 5)
100 101


102 103 104
# Correct: Reversed axes.
class TestUnsqueezeOp4(TestUnsqueezeOp):
    def init_test_case(self):
Z
zhupengyang 已提交
105
        self.ori_shape = (10, 2, 5)
106
        self.axes = (3, 1, 1)
Z
zhupengyang 已提交
107
        self.new_shape = (10, 1, 1, 2, 5, 1)
108 109


110 111
class API_TestUnsqueeze(unittest.TestCase):
    def test_out(self):
112 113 114 115
        paddle.enable_static()
        with paddle.static.program_guard(paddle.static.Program(),
                                         paddle.static.Program()):
            data1 = paddle.static.data('data1', shape=[-1, 10], dtype='float64')
116
            result_squeeze = paddle.unsqueeze(data1, axis=[1])
117 118
            place = paddle.CPUPlace()
            exe = paddle.static.Executor(place)
119 120 121 122 123 124 125 126 127
            input1 = np.random.random([5, 1, 10]).astype('float64')
            input = np.squeeze(input1, axis=1)
            result, = exe.run(feed={"data1": input},
                              fetch_list=[result_squeeze])
            self.assertTrue(np.allclose(input1, result))


class TestUnsqueezeOpError(unittest.TestCase):
    def test_errors(self):
128 129 130
        paddle.enable_static()
        with paddle.static.program_guard(paddle.static.Program(),
                                         paddle.static.Program()):
131 132
            # The type of axis in split_op should be int or Variable.
            def test_axes_type():
133
                x6 = paddle.static.data(
134
                    shape=[-1, 10], dtype='float16', name='x3')
135
                paddle.unsqueeze(x6, axis=3.2)
136 137 138 139 140 141

            self.assertRaises(TypeError, test_axes_type)


class API_TestUnsqueeze2(unittest.TestCase):
    def test_out(self):
142 143 144 145 146
        paddle.enable_static()
        with paddle.static.program_guard(paddle.static.Program(),
                                         paddle.static.Program()):
            data1 = paddle.static.data('data1', shape=[-1, 10], dtype='float64')
            data2 = paddle.static.data('data2', shape=[1], dtype='int32')
147
            result_squeeze = paddle.unsqueeze(data1, axis=data2)
148 149
            place = paddle.CPUPlace()
            exe = paddle.static.Executor(place)
150 151 152 153 154 155 156 157 158 159 160
            input1 = np.random.random([5, 1, 10]).astype('float64')
            input2 = np.array([1]).astype('int32')
            input = np.squeeze(input1, axis=1)
            result1, = exe.run(feed={"data1": input,
                                     "data2": input2},
                               fetch_list=[result_squeeze])
            self.assertTrue(np.allclose(input1, result1))


class API_TestUnsqueeze3(unittest.TestCase):
    def test_out(self):
161 162 163 164 165
        paddle.enable_static()
        with paddle.static.program_guard(paddle.static.Program(),
                                         paddle.static.Program()):
            data1 = paddle.static.data('data1', shape=[-1, 10], dtype='float64')
            data2 = paddle.static.data('data2', shape=[1], dtype='int32')
166
            result_squeeze = paddle.unsqueeze(data1, axis=[data2, 3])
167 168
            place = paddle.CPUPlace()
            exe = paddle.static.Executor(place)
169 170 171 172 173 174
            input1 = np.random.random([5, 1, 10, 1]).astype('float64')
            input2 = np.array([1]).astype('int32')
            input = np.squeeze(input1)
            result1, = exe.run(feed={"data1": input,
                                     "data2": input2},
                               fetch_list=[result_squeeze])
L
Leo Chen 已提交
175 176
            self.assertTrue(np.array_equal(input1, result1))
            self.assertEqual(input1.shape, result1.shape)
177 178 179 180


class API_TestDyUnsqueeze(unittest.TestCase):
    def test_out(self):
181 182 183 184 185 186 187 188
        paddle.disable_static()
        input_1 = np.random.random([5, 1, 10]).astype("int32")
        input1 = np.expand_dims(input_1, axis=1)
        input = paddle.to_tensor(input_1)
        output = paddle.unsqueeze(input, axis=[1])
        out_np = output.numpy()
        self.assertTrue(np.array_equal(input1, out_np))
        self.assertEqual(input1.shape, out_np.shape)
189 190 191 192


class API_TestDyUnsqueeze2(unittest.TestCase):
    def test_out(self):
193 194 195 196 197 198 199 200
        paddle.disable_static()
        input1 = np.random.random([5, 10]).astype("int32")
        out1 = np.expand_dims(input1, axis=1)
        input = paddle.to_tensor(input1)
        output = paddle.unsqueeze(input, axis=1)
        out_np = output.numpy()
        self.assertTrue(np.array_equal(out1, out_np))
        self.assertEqual(out1.shape, out_np.shape)
L
Leo Chen 已提交
201 202 203 204


class API_TestDyUnsqueezeAxisTensor(unittest.TestCase):
    def test_out(self):
205 206 207 208 209 210 211 212 213
        paddle.disable_static()
        input1 = np.random.random([5, 10]).astype("int32")
        out1 = np.expand_dims(input1, axis=1)
        out1 = np.expand_dims(out1, axis=2)
        input = paddle.to_tensor(input1)
        output = paddle.unsqueeze(input, axis=paddle.to_tensor([1, 2]))
        out_np = output.numpy()
        self.assertTrue(np.array_equal(out1, out_np))
        self.assertEqual(out1.shape, out_np.shape)
L
Leo Chen 已提交
214 215 216 217


class API_TestDyUnsqueezeAxisTensorList(unittest.TestCase):
    def test_out(self):
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
        paddle.disable_static()
        input1 = np.random.random([5, 10]).astype("int32")
        # Actually, expand_dims supports tuple since version 1.18.0
        out1 = np.expand_dims(input1, axis=1)
        out1 = np.expand_dims(out1, axis=2)
        input = paddle.to_tensor(input1)
        output = paddle.unsqueeze(
            paddle.to_tensor(input1),
            axis=[paddle.to_tensor([1]), paddle.to_tensor([2])])
        out_np = output.numpy()
        self.assertTrue(np.array_equal(out1, out_np))
        self.assertEqual(out1.shape, out_np.shape)


class API_TestDygraphUnSqueeze(unittest.TestCase):
233 234 235 236 237 238
    def setUp(self):
        self.executed_api()

    def executed_api(self):
        self.unsqueeze = paddle.unsqueeze

239 240 241 242
    def test_out(self):
        paddle.disable_static()
        input_1 = np.random.random([5, 1, 10]).astype("int32")
        input = paddle.to_tensor(input_1)
243
        output = self.unsqueeze(input, axis=[1])
244 245 246 247 248 249 250 251
        out_np = output.numpy()
        expected_out = np.expand_dims(input_1, axis=1)
        self.assertTrue(np.allclose(expected_out, out_np))

    def test_out_int8(self):
        paddle.disable_static()
        input_1 = np.random.random([5, 1, 10]).astype("int8")
        input = paddle.to_tensor(input_1)
252
        output = self.unsqueeze(input, axis=[1])
253 254 255 256 257 258 259 260
        out_np = output.numpy()
        expected_out = np.expand_dims(input_1, axis=1)
        self.assertTrue(np.allclose(expected_out, out_np))

    def test_out_uint8(self):
        paddle.disable_static()
        input_1 = np.random.random([5, 1, 10]).astype("uint8")
        input = paddle.to_tensor(input_1)
261
        output = self.unsqueeze(input, axis=1)
262 263 264 265 266 267 268 269
        out_np = output.numpy()
        expected_out = np.expand_dims(input_1, axis=1)
        self.assertTrue(np.allclose(expected_out, out_np))

    def test_axis_not_list(self):
        paddle.disable_static()
        input_1 = np.random.random([5, 1, 10]).astype("int32")
        input = paddle.to_tensor(input_1)
270
        output = self.unsqueeze(input, axis=1)
271 272 273 274 275 276 277 278
        out_np = output.numpy()
        expected_out = np.expand_dims(input_1, axis=1)
        self.assertTrue(np.allclose(expected_out, out_np))

    def test_dimension_not_1(self):
        paddle.disable_static()
        input_1 = np.random.random([5, 1, 10]).astype("int32")
        input = paddle.to_tensor(input_1)
279
        output = self.unsqueeze(input, axis=(1, 2))
280 281 282
        out_np = output.numpy()
        expected_out = np.expand_dims(input_1, axis=1)
        self.assertTrue(np.allclose(expected_out, out_np))
283 284


285 286 287 288 289
class API_TestDygraphUnSqueezeInplace(API_TestDygraphUnSqueeze):
    def executed_api(self):
        self.unsqueeze = paddle.unsqueeze_


290 291
if __name__ == "__main__":
    unittest.main()