# Copyright (c) 2020 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 import paddle.fluid as fluid import numpy as np import unittest from op_test import OpTest def test_static_layer(place, input_np, label_np, reduction='mean', weight_np=None): prog = paddle.static.Program() startup_prog = paddle.static.Program() with paddle.static.program_guard(prog, startup_prog): input = paddle.fluid.data( name='input', shape=input_np.shape, dtype='float64') label = paddle.fluid.data( name='label', shape=label_np.shape, dtype='float64') if weight_np is not None: weight = paddle.fluid.data( name='weight', shape=weight_np.shape, dtype='float64') bce_loss = paddle.nn.loss.BCELoss( weight=weight, reduction=reduction) else: bce_loss = paddle.nn.loss.BCELoss(reduction=reduction) res = bce_loss(input, label) exe = paddle.static.Executor(place) static_result = exe.run(prog, feed={"input": input_np, "label": label_np} if weight_np is None else { "input": input_np, "label": label_np, "weight": weight_np }, fetch_list=[res]) return static_result def test_static_functional(place, input_np, label_np, reduction='mean', weight_np=None): prog = paddle.static.Program() startup_prog = paddle.static.Program() with paddle.static.program_guard(prog, startup_prog): input = paddle.fluid.data( name='input', shape=input_np.shape, dtype='float64') label = paddle.fluid.data( name='label', shape=label_np.shape, dtype='float64') if weight_np is not None: weight = paddle.fluid.data( name='weight', shape=weight_np.shape, dtype='float64') res = paddle.nn.functional.binary_cross_entropy( input, label, weight=weight, reduction=reduction) else: res = paddle.nn.functional.binary_cross_entropy( input, label, reduction=reduction) exe = paddle.static.Executor(place) static_result = exe.run(prog, feed={"input": input_np, "label": label_np} if weight_np is None else { "input": input_np, "label": label_np, "weight": weight_np }, fetch_list=[res]) return static_result def test_dygraph_layer(place, input_np, label_np, reduction='mean', weight_np=None): paddle.disable_static() if weight_np is not None: weight = paddle.to_tensor(weight_np) bce_loss = paddle.nn.loss.BCELoss(weight=weight, reduction=reduction) else: bce_loss = paddle.nn.loss.BCELoss(reduction=reduction) dy_res = bce_loss(paddle.to_tensor(input_np), paddle.to_tensor(label_np)) dy_result = dy_res.numpy() paddle.enable_static() return dy_result def test_dygraph_functional(place, input_np, label_np, reduction='mean', weight_np=None): paddle.disable_static() input = paddle.to_tensor(input_np) label = paddle.to_tensor(label_np) if weight_np is not None: weight = paddle.to_tensor(weight_np) dy_res = paddle.nn.functional.binary_cross_entropy( input, label, weight=weight, reduction=reduction) else: dy_res = paddle.nn.functional.binary_cross_entropy( input, label, reduction=reduction) dy_result = dy_res.numpy() paddle.enable_static() return dy_result def calc_bceloss(input_np, label_np, reduction='mean', weight_np=None): if weight_np is None: expected = -1 * (label_np * np.log(input_np) + (1. - label_np) * np.log(1. - input_np)) else: expected = -1 * weight_np * (label_np * np.log(input_np) + (1. - label_np) * np.log(1. - input_np)) if reduction == 'mean': expected = np.mean(expected) elif reduction == 'sum': expected = np.sum(expected) else: expected = expected return expected class TestBCELoss(unittest.TestCase): def test_BCELoss(self): input_np = np.random.uniform(0.1, 0.8, size=(20, 30)).astype(np.float64) label_np = np.random.randint(0, 2, size=(20, 30)).astype(np.float64) places = [fluid.CPUPlace()] if fluid.core.is_compiled_with_cuda(): places.append(fluid.CUDAPlace(0)) reductions = ['sum', 'mean', 'none'] for place in places: for reduction in reductions: static_result = test_static_layer(place, input_np, label_np, reduction) dy_result = test_dygraph_layer(place, input_np, label_np, reduction) expected = calc_bceloss(input_np, label_np, reduction) self.assertTrue(np.allclose(static_result, expected)) self.assertTrue(np.allclose(static_result, dy_result)) self.assertTrue(np.allclose(dy_result, expected)) static_functional = test_static_functional(place, input_np, label_np, reduction) dy_functional = test_dygraph_functional(place, input_np, label_np, reduction) self.assertTrue(np.allclose(static_functional, expected)) self.assertTrue(np.allclose(static_functional, dy_functional)) self.assertTrue(np.allclose(dy_functional, expected)) def test_BCELoss_weight(self): input_np = np.random.uniform( 0.1, 0.8, size=(2, 3, 4, 10)).astype(np.float64) label_np = np.random.randint( 0, 2, size=(2, 3, 4, 10)).astype(np.float64) weight_np = np.random.random(size=(3, 4, 10)).astype(np.float64) place = fluid.CUDAPlace(0) if fluid.core.is_compiled_with_cuda( ) else fluid.CPUPlace() for reduction in ['sum', 'mean', 'none']: static_result = test_static_layer( place, input_np, label_np, reduction, weight_np=weight_np) dy_result = test_dygraph_layer( place, input_np, label_np, reduction, weight_np=weight_np) expected = calc_bceloss( input_np, label_np, reduction, weight_np=weight_np) self.assertTrue(np.allclose(static_result, expected)) self.assertTrue(np.allclose(static_result, dy_result)) self.assertTrue(np.allclose(dy_result, expected)) static_functional = test_static_functional( place, input_np, label_np, reduction, weight_np=weight_np) dy_functional = test_dygraph_functional( place, input_np, label_np, reduction, weight_np=weight_np) self.assertTrue(np.allclose(static_functional, expected)) self.assertTrue(np.allclose(static_functional, dy_functional)) self.assertTrue(np.allclose(dy_functional, expected)) def test_BCELoss_error(self): paddle.disable_static() self.assertRaises( ValueError, paddle.nn.loss.BCELoss, reduction="unsupport reduction") input = paddle.to_tensor([[0.1, 0.3]], dtype='float32') label = paddle.to_tensor([[0.0, 1.0]], dtype='float32') self.assertRaises( ValueError, paddle.nn.functional.binary_cross_entropy, input=input, label=label, reduction="unsupport reduction") paddle.enable_static() def bce_loss(input, label): return -1 * (label * np.log(input) + (1. - label) * np.log(1. - input)) class TestBceLossOp(OpTest): def setUp(self): self.init_test_case() self.op_type = "bce_loss" input_np = np.random.uniform(0.1, 0.8, self.shape).astype("float64") label_np = np.random.randint(0, 2, self.shape).astype("float64") output_np = bce_loss(input_np, label_np) self.inputs = {'X': input_np, 'Label': label_np} self.outputs = {'Out': output_np} def test_check_output(self): self.check_output() def test_check_grad(self): self.check_grad(['X'], 'Out') def init_test_case(self): self.shape = [10, 10] class TestBceLossOpCase1(OpTest): def init_test_cast(self): self.shape = [2, 3, 4, 5] class TestBceLossOpCase2(OpTest): def init_test_cast(self): self.shape = [2, 3, 20] if __name__ == "__main__": paddle.enable_static() unittest.main()