Revise logical and

docs/ops/logical/LogicalAnd_1.md

@@ -6,6 +6,14 @@
 
 **Short description**: *LogicalAnd* performs element-wise logical AND operation with two given tensors applying multi-directional broadcast rules.
 
+**Detailed description**: Before performing logical operation, input tensors *a* and *b* are broadcasted if their shapes are different and `auto_broadcast` attributes is not `none`. Broadcasting is performed according to `auto_broadcast` value.
+
+After broadcasting *LogicalAnd* does the following with the input tensors *a* and *b*:
+
+\f[
+o_{i} = a_{i} and b_{i}
+\f]
+
 **Attributes**:
 
 * *auto_broadcast*
@@ -20,25 +28,17 @@
 
 **Inputs**
 
-* **1**: A tensor of type *T*. **Required.**
-* **2**: A tensor of type *T*. **Required.**
+* **1**: A tensor of type *T* and arbitrary shape. **Required.**
+* **2**: A tensor of type *T* and arbitrary shape. **Required.**
 
 **Outputs**
 
-* **1**: The result of element-wise logical AND operation. A tensor of type boolean.
+* **1**: The result of element-wise *LogicalAnd* operation. A tensor of type boolean.
 
 **Types**
 
 * *T*: boolean type.
 
-**Detailed description**
-Before performing logical operation, input tensors *a* and *b* are broadcasted if their shapes are different and `auto_broadcast` attributes is not `none`. Broadcasting is performed according to `auto_broadcast` value.
-
-After broadcasting *LogicalAnd* does the following with the input tensors *a* and *b*:
-
-\f[
-o_{i} = a_{i} and b_{i}
-\f]
 
 **Examples**
 

docs/template_plugin/tests/functional/op_reference/logical_and.cpp

@@ -0,0 +1,101 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+
+#include <ie_core.hpp>
+#include <ie_ngraph_utils.hpp>
+#include <ngraph/ngraph.hpp>
+#include <shared_test_classes/base/layer_test_utils.hpp>
+#include <tuple>
+
+#include "base_reference_test.hpp"
+
+using namespace ngraph;
+using namespace InferenceEngine;
+
+namespace {
+struct LogicalAndParams {
+    template <class IT, class OT>
+    LogicalAndParams(const ngraph::PartialShape& input_shape1, const ngraph::PartialShape& input_shape2 , const ngraph::element::Type& iType,
+                const ngraph::element::Type& oType, const std::vector<IT>& iValues1, const std::vector<IT>& iValues2, const std::vector<OT>& oValues)
+        : pshape1(input_shape1), pshape2(input_shape2), inType(iType), outType(oType), inputData1(CreateBlob(iType, iValues1)),
+        inputData2(CreateBlob(iType, iValues2)), refData(CreateBlob(oType, oValues)) {}
+    ngraph::PartialShape pshape1;
+    ngraph::PartialShape pshape2;
+    ngraph::element::Type inType;
+    ngraph::element::Type outType;
+    InferenceEngine::Blob::Ptr inputData1;
+    InferenceEngine::Blob::Ptr inputData2;
+    InferenceEngine::Blob::Ptr refData;
+};
+
+class ReferenceLogicalAndLayerTest : public testing::TestWithParam<LogicalAndParams>, public CommonReferenceTest {
+public:
+    void SetUp() override {
+        auto params = GetParam();
+        function = CreateFunction(params.pshape1, params.pshape2, params.inType);
+        inputData = {params.inputData1, params.inputData2};
+        refOutData = {params.refData};
+    }
+    static std::string getTestCaseName(const testing::TestParamInfo<LogicalAndParams>& obj) {
+        auto param = obj.param;
+        std::ostringstream result;
+        result << "input_shape1=" << param.pshape1 << "_";
+        result << "input_shape2=" << param.pshape2 << "_";
+        result << "iType=" << param.inType << "_";
+        result << "oType=" << param.outType;
+        return result.str();
+    }
+
+private:
+    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1, const PartialShape& input_shape2, const element::Type& input_type) {
+        const auto in = std::make_shared<op::Parameter>(input_type, input_shape1);
+        const auto in2 = std::make_shared<op::Parameter>(input_type, input_shape2);
+        const auto logical_and = std::make_shared<op::v1::LogicalAnd>(in, in2);
+        return std::make_shared<Function>(NodeVector {logical_and}, ParameterVector {in, in2});
+    }
+};
+
+TEST_P(ReferenceLogicalAndLayerTest, CompareWithHardcodedRefs) {
+    Exec();
+}
+
+template <element::Type_t IN_ET>
+std::vector<LogicalAndParams> generateLogicalAndParams(const ngraph::element::Type& type) {
+    using T = typename element_type_traits<IN_ET>::value_type;
+    std::vector<LogicalAndParams> logicalAndParams {
+        // 1D // 2D // 3D // 4D
+        LogicalAndParams(ngraph::PartialShape {2, 2}, ngraph::PartialShape {2, 2}, type, ngraph::element::boolean,
+                std::vector<T> {true, false, true, false},
+                std::vector<T> {false, true, true, false},
+                std::vector<char> {false, false, true, false}),
+        LogicalAndParams(ngraph::PartialShape {1}, ngraph::PartialShape {1},  type, ngraph::element::boolean,
+                std::vector<T> {true},
+                std::vector<T> {true},
+                std::vector<char> {true}),
+
+        LogicalAndParams(ngraph::PartialShape {2, 1, 2, 1}, ngraph::PartialShape {1, 1, 2, 1}, type, ngraph::element::boolean,
+                std::vector<T> {true, false, true, false},
+                std::vector<T> {true, false},
+                std::vector<char> {true, false, true, false}),
+        LogicalAndParams(ngraph::PartialShape {3, 4}, ngraph::PartialShape {3, 4}, type, ngraph::element::boolean,
+                std::vector<T> {true, true, true, true, true, false, true, false, false, true, true, true},
+                std::vector<T> {true, true, true, true, true, false, true, false, false, true, true, false},
+                std::vector<char> {true, true, true, true, true, false, true, false, false, true, true, false})};
+    return logicalAndParams;
+}
+
+std::vector<LogicalAndParams> generateLogicalAndCombinedParams() {
+    const std::vector<std::vector<LogicalAndParams>> logicalAndTypeParams {generateLogicalAndParams<element::Type_t::u8>(ngraph::element::boolean)};
+    std::vector<LogicalAndParams> combinedParams;
+    std::for_each(logicalAndTypeParams.begin(), logicalAndTypeParams.end(), [&](std::vector<LogicalAndParams> params) {
+        combinedParams.insert(combinedParams.end(), params.begin(), params.end());
+    });
+    return combinedParams;
+}
+
+INSTANTIATE_TEST_SUITE_P(smoke_LogicalAnd_With_Hardcoded_Refs, ReferenceLogicalAndLayerTest, ::testing::ValuesIn(generateLogicalAndCombinedParams()),
+                                 ReferenceLogicalAndLayerTest::getTestCaseName);
+}  // namespace

inference-engine/tests/functional/inference_engine/serialization/single_layer/logical.cpp

@@ -0,0 +1,84 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vector>
+#include "shared_test_classes/single_layer/logical.hpp"
+#include "common_test_utils/test_constants.hpp"
+
+using namespace LayerTestsDefinitions;
+using namespace LayerTestsDefinitions::LogicalParams;
+
+namespace {
+TEST_P(LogicalLayerTest, Serialize) {
+    Serialize();
+}
+
+std::map<std::vector<size_t>, std::vector<std::vector<size_t >>> inputShapes = {
+        {{1}, {{1}, {17}, {1, 1}, {2, 18}, {1, 1, 2}, {2, 2, 3}, {1, 1, 2, 3}}},
+        {{5}, {{1}, {1, 1}, {2, 5}, {1, 1, 1}, {2, 2, 5}}},
+        {{2, 200}, {{1}, {200}, {1, 200}, {2, 200}, {2, 2, 200}}},
+        {{1, 3, 20}, {{20}, {2, 1, 1}}},
+        {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {2, 1, 3, 4}}},
+        {{2, 1, 1, 3, 1}, {{1}, {1, 3, 4}, {2, 1, 3, 4}, {1, 1, 1, 1, 1}}},
+};
+
+std::map<std::vector<size_t>, std::vector<std::vector<size_t >>> inputShapesNot = {
+        {{1}, {}},
+        {{5}, {}},
+        {{2, 200}, {}},
+        {{1, 3, 20}, {}},
+        {{2, 17, 3, 4}, {}},
+        {{2, 1, 1, 3, 1}, {}},
+};
+
+std::vector<InferenceEngine::Precision> inputsPrecisions = {
+        InferenceEngine::Precision::BOOL,
+};
+
+std::vector<ngraph::helpers::LogicalTypes> logicalOpTypes = {
+        ngraph::helpers::LogicalTypes::LOGICAL_AND,
+        ngraph::helpers::LogicalTypes::LOGICAL_OR,
+        ngraph::helpers::LogicalTypes::LOGICAL_XOR,
+};
+
+std::vector<ngraph::helpers::InputLayerType> secondInputTypes = {
+        ngraph::helpers::InputLayerType::CONSTANT,
+        ngraph::helpers::InputLayerType::PARAMETER,
+};
+
+std::vector<InferenceEngine::Precision> netPrecisions = {
+        InferenceEngine::Precision::FP32,
+};
+
+std::map<std::string, std::string> additional_config = {};
+
+const auto LogicalTestParams = ::testing::Combine(
+        ::testing::ValuesIn(LogicalLayerTest::combineShapes(inputShapes)),
+        ::testing::ValuesIn(logicalOpTypes),
+        ::testing::ValuesIn(secondInputTypes),
+        ::testing::ValuesIn(netPrecisions),
+        ::testing::ValuesIn(inputsPrecisions),
+        ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
+        ::testing::Values(InferenceEngine::Layout::ANY),
+        ::testing::Values(InferenceEngine::Layout::ANY),
+        ::testing::Values(CommonTestUtils::DEVICE_CPU),
+        ::testing::Values(additional_config));
+
+const auto LogicalTestParamsNot = ::testing::Combine(
+        ::testing::ValuesIn(LogicalLayerTest::combineShapes(inputShapesNot)),
+        ::testing::Values(ngraph::helpers::LogicalTypes::LOGICAL_NOT),
+        ::testing::Values(ngraph::helpers::InputLayerType::CONSTANT),
+        ::testing::ValuesIn(netPrecisions),
+        ::testing::ValuesIn(inputsPrecisions),
+        ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
+        ::testing::Values(InferenceEngine::Layout::ANY),
+        ::testing::Values(InferenceEngine::Layout::ANY),
+        ::testing::Values(CommonTestUtils::DEVICE_CPU),
+        ::testing::Values(additional_config));
+
+INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, LogicalLayerTest, LogicalTestParams, LogicalLayerTest::getTestCaseName);
+
+INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefsNot, LogicalLayerTest, LogicalTestParamsNot, LogicalLayerTest::getTestCaseName);
+
+}  // namespace

inference-engine/tests/ie_test_utils/functional_test_utils/layer_tests_summary/utils/constants.py

@@ -54,6 +54,7 @@
     'LRN-1',
     'LSTMCell-4',
     'LSTMSequence-5',
+    'LogicalAnd-1'
     'LogSoftmax-5',
     'Loop-5',
     'MVN-6',

ngraph/core/src/op/and.cpp

@@ -7,6 +7,8 @@
 #include "ngraph/runtime/host_tensor.hpp"
 #include "ngraph/runtime/reference/and.hpp"
 
+#include "ngraph/validation_util.hpp"
+
 using namespace std;
 using namespace ngraph;
 
@@ -77,6 +79,7 @@ bool op::v1::LogicalAnd::evaluate(const HostTensorVector& outputs,
                                   const HostTensorVector& inputs) const
 {
     NGRAPH_OP_SCOPE(v1_LogicalAnd_evaluate);
+    NGRAPH_CHECK(validate_host_tensor_vector(outputs, 1) && validate_host_tensor_vector(inputs, 2));
     return logand::evaluate_logand(inputs[0], inputs[1], outputs[0], get_autob());
 }
 

ngraph/test/CMakeLists.txt

@@ -151,6 +151,7 @@ set(SRC
     type_prop/hswish.cpp
     type_prop/idft.cpp
     type_prop/interpolate.cpp
+    type_prop/logical_and.cpp
     type_prop/lrn.cpp
     type_prop/lstm_cell.cpp
     type_prop/lstm_sequence.cpp
@@ -260,6 +261,7 @@ set(SRC
     visitors/op/group_conv.cpp
     visitors/op/interpolate.cpp
     visitors/op/log.cpp
+    visitors/op/logical_and.cpp
     visitors/op/logical_xor.cpp
     visitors/op/lrn.cpp
     visitors/op/lstm_cell.cpp

ngraph/test/type_prop/logical_and.cpp

@@ -0,0 +1,127 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "gtest/gtest.h"
+#include "ngraph/ngraph.hpp"
+#include "util/type_prop.hpp"
+
+using namespace std;
+using namespace ngraph;
+
+TEST(type_prop, logical_and_incorrect_type_f32)
+{
+    auto input1 = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
+    auto input2 = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
+    try
+    {
+        auto logical_and = make_shared<op::v1::LogicalAnd>(input1, input2);
+    }
+    catch (const NodeValidationFailure& error)
+    {
+        EXPECT_HAS_SUBSTRING(error.what(),
+                             std::string("Operands for logical operators must have boolean element type but have element type f32"));
+    }
+
+}
+
+TEST(type_prop, logical_and_incorrect_type_f64)
+{
+    auto input1 = make_shared<op::Parameter>(element::f64, Shape{1, 3, 6});
+    auto input2 = make_shared<op::Parameter>(element::f64, Shape{1, 3, 6});
+    try
+    {
+        auto logical_and = make_shared<op::v1::LogicalAnd>(input1, input2);
+    }
+    catch (const NodeValidationFailure& error)
+    {
+        EXPECT_HAS_SUBSTRING(error.what(),
+                             std::string("Operands for logical operators must have boolean element type but have element type f64"));
+    }
+}
+
+TEST(type_prop, logical_and_incorrect_type_i32)
+{
+    auto input1 = make_shared<op::Parameter>(element::i32, Shape{1, 3, 6});
+    auto input2 = make_shared<op::Parameter>(element::i32, Shape{1, 3, 6});
+    try
+    {
+        auto logical_and = make_shared<op::v1::LogicalAnd>(input1, input2);
+    }
+    catch (const NodeValidationFailure& error)
+    {
+        EXPECT_HAS_SUBSTRING(error.what(),
+                             std::string("Operands for logical operators must have boolean element type but have element type i32"));
+    }
+}
+
+TEST(type_prop, logical_and_incorrect_type_i64)
+{
+    auto input1 = make_shared<op::Parameter>(element::i64, Shape{1, 3, 6});
+    auto input2 = make_shared<op::Parameter>(element::i64, Shape{1, 3, 6});
+    try
+    {
+        auto logical_and = make_shared<op::v1::LogicalAnd>(input1, input2);
+    }
+    catch (const NodeValidationFailure& error)
+    {
+        EXPECT_HAS_SUBSTRING(error.what(),
+                             std::string("Operands for logical operators must have boolean element type but have element type i64"));
+    }
+}
+
+TEST(type_prop, logical_and_incorrect_type_u32)
+{
+    auto input1 = make_shared<op::Parameter>(element::u32, Shape{1, 3, 6});
+    auto input2 = make_shared<op::Parameter>(element::u32, Shape{1, 3, 6});
+    try
+    {
+        auto logical_and = make_shared<op::v1::LogicalAnd>(input1, input2);
+    }
+    catch (const NodeValidationFailure& error)
+    {
+        EXPECT_HAS_SUBSTRING(error.what(),
+                             std::string("Operands for logical operators must have boolean element type but have element type u32"));
+    }
+}
+
+TEST(type_prop, logical_and_incorrect_type_u64)
+{
+    auto input1 = make_shared<op::Parameter>(element::u64, Shape{1, 3, 6});
+    auto input2 = make_shared<op::Parameter>(element::u64, Shape{1, 3, 6});
+    try
+    {
+        auto logical_and = make_shared<op::v1::LogicalAnd>(input1, input2);
+    }
+    catch (const NodeValidationFailure& error)
+    {
+        EXPECT_HAS_SUBSTRING(error.what(),
+                             std::string("Operands for logical operators must have boolean element type but have element type u64"));
+    }
+}
+
+TEST(type_prop, logical_and_incorrect_shape)
+{
+    auto input1 = make_shared<op::Parameter>(element::boolean, Shape{1, 3, 6});
+    auto input2 = make_shared<op::Parameter>(element::boolean, Shape{1, 2, 6});
+    try
+    {
+        auto logical_and = make_shared<op::v1::LogicalAnd>(input1, input2);
+    }
+    catch (const NodeValidationFailure& error)
+    {
+        EXPECT_HAS_SUBSTRING(error.what(),
+                             std::string("Argument shapes are inconsistent"));
+    }
+}
+
+TEST(type_prop, logical_and_broadcast)
+{
+    auto input1 = make_shared<op::Parameter>(element::boolean, Shape{1, 1, 6});
+    auto input2 = make_shared<op::Parameter>(element::boolean, Shape{1, 3, 1});
+
+    auto logical_and = make_shared<op::v1::LogicalAnd>(input1, input2);
+
+    ASSERT_EQ(logical_and->get_element_type(), element::boolean);
+    ASSERT_EQ(logical_and->get_shape(), (Shape{1, 3, 6}));
+}