Merge branch 'master' into r0.12

Author: avijit-nervana

CMakeLists.txt

@@ -239,7 +239,7 @@ if (NOT USE_PRE_BUILT_NGRAPH)
     ExternalProject_Add(
         ext_ngraph
         GIT_REPOSITORY https://github.com/NervanaSystems/ngraph
-        GIT_TAG v0.17.0-rc.1
+        GIT_TAG v0.18.0-rc.1
         CMAKE_ARGS 
             -DNGRAPH_DISTRIBUTED_ENABLE=${NGRAPH_DISTRIBUTED_ENABLE}
             -DNGRAPH_INSTALL_PREFIX=${NGRAPH_ARTIFACTS_DIR}

README.md

@@ -47,8 +47,8 @@ a variety of nGraph-enabled backends: CPU, GPU, and custom silicon like the
 This will produce something like this:
 
         TensorFlow version:  1.13.1
-        nGraph bridge version: b'0.12.0-rc4'
-        nGraph version used for this build: b'0.17.0-rc.1+045b71e'
+        nGraph bridge version: b'0.12.0-rc5'
+        nGraph version used for this build: b'0.18.0-rc.1+55e1e17'
         TensorFlow version used for this build: v1.13.1-0-g6612da8951
         CXX11_ABI flag used for this build: 1
 

bazel/WORKSPACE

@@ -25,11 +25,11 @@ tf_configure(
 http_archive(
     name = "ngraph",
     build_file = "//:bazel/ngraph.BUILD",
-    sha256 = "517f2430ab1434021c2c4e3daf6f52cc855e4134632ed7c517a2c9c4b2c28f6b",
-    strip_prefix = "ngraph-0.17.0-rc.1",
+    sha256 = "8a0618901d96e016684fb9dc2b2e29fb648e5b32085bfbc6cc24b152bab5e8aa",
+    strip_prefix = "ngraph-0.18.0-rc.1",
     urls = [
-        "https://mirror.bazel.build/github.com/NervanaSystems/ngraph/archive/v0.17.0-rc.1.tar.gz",
-        "https://github.com/NervanaSystems/ngraph/archive/v0.17.0-rc.1.tar.gz",
+        "https://mirror.bazel.build/github.com/NervanaSystems/ngraph/archive/v0.18.0-rc.1.tar.gz",
+        "https://github.com/NervanaSystems/ngraph/archive/v0.18.0-rc.1.tar.gz",
     ],
 )
 

build_ngtf.py

@@ -24,7 +24,7 @@ def main():
     '''
 
     # Component versions
-    ngraph_version = "v0.17.0-rc.1"
+    ngraph_version = "v0.18.0-rc.1"
     tf_version = "v1.13.1"
 
     # Command line parser options

python/CreatePipWhl.cmake

@@ -47,8 +47,10 @@ if (PYTHON)
     file(GLOB NGRAPH_LIB_FILES "${NGTF_INSTALL_DIR}/${LIB_SUFFIX}/lib*")
 
     # Copy the ngraph_bridge include from install
+    message(STATUS "NGTF_INSTALL_DIR: ${NGTF_INSTALL_DIR}")
+    
     file(
-        COPY "${NGTF_INSTALL_DIR}/include" 
+        COPY "${NGRAPH_INSTALL_DIR}/include" 
         DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/python/ngraph_bridge"
     )
 

python/setup.in.py

@@ -39,7 +39,7 @@ def get_tag(self):
 
 setup( 
     name='ngraph_tensorflow_bridge',
-    version='0.12.0rc4',
+    version='0.12.0rc5',
     description='Intel nGraph compiler and runtime for TensorFlow',
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -52,7 +52,7 @@ def get_tag(self):
     package_data=
     {
         'ngraph_bridge': [
-            "include/ngraph/*",
+            "include/ngraph/**/*",
             @ngraph_libraries@ @license_files@ @licence_top_level@
         ],
     },

src/ngraph_builder.cc

@@ -16,8 +16,10 @@
 
 #include "ngraph_builder.h"
 #include "ngraph/op/util/logical_reduction.hpp"
+#include "ngraph_backend_manager.h"
 #include "ngraph_conversions.h"
 #include "ngraph_log.h"
+#include "ngraph_mark_for_clustering.h"
 #include "ngraph_utils.h"
 
 #include "ngraph/builder/autobroadcast.hpp"
@@ -1914,6 +1916,90 @@ static Status TranslateFusedBatchNormGradOp(
   return Status::OK();
 }
 
+static Status TranslateGatherV2Op(
+    const Node* op, const std::vector<const Tensor*>& static_input_map,
+    Builder::OpMap& ng_op_map) {
+  shared_ptr<ng::Node> ng_input;
+  TF_RETURN_IF_ERROR(GetInputNode(ng_op_map, op, 0, &ng_input));
+
+  std::vector<int64> tf_indices;
+  TF_RETURN_IF_ERROR(
+      GetStaticInputVector(op, 1, static_input_map, &tf_indices));
+  // It seems indices cannot be negative, so no need to handle that
+  std::vector<size_t> indices(tf_indices.size());
+  std::transform(tf_indices.begin(), tf_indices.end(), indices.begin(),
+                 [](int64 x) { return (size_t)(x); });
+
+  std::vector<int64> tf_axis;
+  TF_RETURN_IF_ERROR(GetStaticInputVector(op, 2, static_input_map, &tf_axis));
+
+  if (tf_axis.size() > 1) {
+    return errors::Internal("Found axis in GatherV2 op (", op->name(),
+                            ") translation to be non scalar, of size ",
+                            tf_axis.size());
+  }
+
+  std::string backend_name;
+  TF_RETURN_IF_ERROR(ngraph_bridge::GetNodeBackend(op, &backend_name));
+
+  if (backend_name != "NNPI") {
+    return errors::Internal("In translating GatherV2 op ", op->name(),
+                            " found requested backend ", backend_name,
+                            " which is unsupported");
+  }
+
+  ng::runtime::Backend* backend = BackendManager::GetBackend(backend_name);
+  auto coords = ng::Coordinate(indices);
+  // Negative axis is supported. Accounting for that
+  auto ng_input_shape = ng_input->get_shape();
+  size_t ng_input_rank = ng_input_shape.size();
+  size_t axis;
+  if (tf_axis[0] >= 0) {
+    axis = tf_axis[0];
+  } else {
+    axis = tf_axis[0] + ng_input_rank;
+  }
+  if (axis < 0 || axis >= ng_input_rank) {
+    return errors::InvalidArgument("Expected axis in the range [-",
+                                   ng_input_rank, ", ", ng_input_rank,
+                                   "), but got ", tf_axis[0]);
+  }
+
+  for (size_t indices_idx = 0; indices_idx < indices.size(); indices_idx++) {
+    if (indices[indices_idx] >= ng_input_shape[axis]) {
+      // TODO: this error returnign must be generalized when indices = vector of
+      // vectors is supported
+      return errors::InvalidArgument("indices[0,", indices_idx, "] = ",
+                                     indices[indices_idx], " is not in [0, ",
+                                     ng_input_shape[axis], ")");
+    }
+  }
+
+  vector<size_t> possibly_empty_node_size(ng_input_shape);
+  possibly_empty_node_size[axis] = indices.size();
+
+  if (std::any_of(possibly_empty_node_size.begin(),
+                  possibly_empty_node_size.end(),
+                  [](size_t x) { return x == 0; })) {
+    std::vector<std::string> const_values(
+        ng::shape_size(possibly_empty_node_size), "0");
+    auto ng_empty = ConstructNgNode<ng::op::Constant>(
+        op->name(), ng_input->get_element_type(),
+        ng::Shape(possibly_empty_node_size), const_values);
+    SaveNgOp(ng_op_map, op->name(), ng_empty);
+  } else {
+    shared_ptr<ng::Node> ng_gather =
+        backend->get_backend_op("Gather", &ng_input, &coords, &axis);
+    if (ng_gather == nullptr) {
+      return errors::Internal("In translating GatherV2 op ", op->name(),
+                              " backend could not return valid ngraph node");
+    }
+    SaveNgOp(ng_op_map, op->name(), ng_gather);
+  }
+
+  return Status::OK();
+}
+
 static Status TranslateFusedConv2DOp(
     const Node* op, const std::vector<const Tensor*>& static_input_map,
     Builder::OpMap& ng_op_map) {
@@ -4252,6 +4338,7 @@ const static std::map<
         {"FusedBatchNorm", TranslateFusedBatchNormOp},
         {"FusedBatchNormV2", TranslateFusedBatchNormOp},
         {"FusedBatchNormGrad", TranslateFusedBatchNormGradOp},
+        {"GatherV2", TranslateGatherV2Op},
         {"_FusedConv2D", TranslateFusedConv2DOp},
         {"Greater", TranslateBinaryOp<ngraph::op::Greater>},
         {"GreaterEqual", TranslateBinaryOp<ngraph::op::GreaterEq>},

src/ngraph_mark_for_clustering.cc

@@ -430,6 +430,9 @@ Status MarkForClustering(Graph* graph,
       // DT_FLOAT
       type_constraint_map["FusedBatchNormV2"]["T"] = {DT_FLOAT};
       type_constraint_map["FusedBatchNormGrad"]["T"] = NGraphNumericDTypes();
+      type_constraint_map["GatherV2"]["Tparams"] = NGraphDTypes();
+      type_constraint_map["GatherV2"]["Tindices"] = NGraphIndexDTypes();
+      type_constraint_map["GatherV2"]["Taxis"] = NGraphIndexDTypes();
       type_constraint_map["_FusedConv2D"]["T"] = NGraphRealDTypes();
       type_constraint_map["Greater"]["T"] = NGraphDTypes();
       type_constraint_map["GreaterEqual"]["T"] = NGraphDTypes();
@@ -567,6 +570,7 @@ Status MarkForClustering(Graph* graph,
       set_attributes_map["Conv2DBackpropInput"] = SetStaticInputs({0});
       set_attributes_map["ExpandDims"] = SetStaticInputs({1});
       set_attributes_map["Fill"] = SetStaticInputs({0});
+      set_attributes_map["GatherV2"] = SetStaticInputs({1, 2});
       set_attributes_map["Max"] = SetStaticInputs({1});
       set_attributes_map["Mean"] = SetStaticInputs({1});
       set_attributes_map["Min"] = SetStaticInputs({1});
@@ -608,6 +612,33 @@ Status MarkForClustering(Graph* graph,
     }
   }
 
+  // Set Attributes for nodes marked for clustering
+  // 1. Set Attribute "_ngraph_marked_for_clustering" as "true"
+  // 2. Set the backend for each op
+  // 3. Set any other attributes as defined in set_attribute_map
+  string current_backend = BackendManager::GetCurrentlySetBackendName();
+  const char* ng_backend_env_value = std::getenv("NGRAPH_TF_BACKEND");
+  if (ng_backend_env_value != nullptr) {
+    string backend_env = std::string(ng_backend_env_value);
+    if (backend_env.empty() ||
+        !BackendManager::IsSupportedBackend(backend_env)) {
+      return errors::Internal("NGRAPH_TF_BACKEND: ", backend_env,
+                              " is not supported");
+    }
+    current_backend = backend_env;
+    // TODO: set backend. Then don't use current_backend
+  }
+
+  // Right now it cannot be inside the if(!initialized) block, because it is
+  // backend dependent, which might change with different sess.run()s
+  confirmation_function_map["GatherV2"] = [&current_backend](Node* n,
+                                                             bool* result) {
+    // TODO: replace current_backend ->
+    // BackendManager::GetCurrentlySetBackendName()
+    *result = (current_backend == "NNPI");
+    return Status::OK();
+  };
+
   std::unordered_map<string, int> no_support_histogram;
   std::unordered_map<string, int> fail_confirmation_histogram;
   std::unordered_map<string, int> fail_constraint_histogram;
@@ -692,23 +723,6 @@ Status MarkForClustering(Graph* graph,
     std::cout << "\n";
   }
 
-  // Set Attributes for nodes marked for clustering
-  // 1. Set Attribute "_ngraph_marked_for_clustering" as "true"
-  // 2. Set the backend for each op
-  // 3. Set any other attributes as defined in set_attribute_map
-  string current_backend = BackendManager::GetCurrentlySetBackendName();
-  const char* ng_backend_env_value = std::getenv("NGRAPH_TF_BACKEND");
-  if (ng_backend_env_value != nullptr) {
-    string backend_env = std::string(ng_backend_env_value);
-    if (backend_env.empty() ||
-        !BackendManager::IsSupportedBackend(backend_env)) {
-      return errors::Internal("NGRAPH_TF_BACKEND: ", backend_env,
-                              " is not supported");
-    }
-    current_backend = backend_env;
-  }
-  NGRAPH_VLOG(5) << "Found NG Backend " << current_backend;
-
   for (auto node : nodes_marked_for_clustering) {
     // TODO(amprocte): move attr name to a constant
     node->AddAttr("_ngraph_marked_for_clustering", true);
@@ -743,7 +757,7 @@ bool InputIsStatic(const Node* node, int index) {
   return std::find(inputs.begin(), inputs.end(), index) != inputs.end();
 }
 
-Status GetNodeBackend(Node* node, string* backend_name) {
+Status GetNodeBackend(const Node* node, string* backend_name) {
   // TODO(amprocte): move attr name to a constant
   NGRAPH_VLOG(5) << "Getting backend " << node->name();
   TF_RETURN_IF_ERROR(

src/ngraph_mark_for_clustering.h

@@ -28,7 +28,7 @@ Status MarkForClustering(Graph* graph, std::vector<string> skip_these_nodes);
 bool NodeIsMarkedForClustering(const Node* node);
 void GetStaticInputs(const Node* node, std::vector<int32>* inputs);
 bool InputIsStatic(const Node* node, int index);
-Status GetNodeBackend(Node* node, string* backend_name);
+Status GetNodeBackend(const Node* node, string* backend_name);
 void SetNodeBackend(Node* node, string& backend_name);
 }  // namespace ngraph_bridge
 

src/version.cc

@@ -30,7 +30,7 @@
 // candidate such as v0.7.0-rc0
 // The code in master will always have the last released version number
 // with a suffix of '-master'
-#define NG_TF_VERSION_SUFFIX "-rc4"
+#define NG_TF_VERSION_SUFFIX "-rc5"
 
 #define VERSION_STR_HELPER(x) #x
 #define VERSION_STR(x) VERSION_STR_HELPER(x)

test/python/tensorflow/python_tests_list.txt

@@ -171,7 +171,26 @@ depthtospace_op_test.DepthToSpaceTest.testDepthInterleavedLarger
 depthtospace_op_test.DepthToSpaceTest.testNonSquare
 
 #dequantize_op_test.DequantizeOpTest.testBasicQuint8 
-#dequantize_op_test.DequantizeOpTest.testBasicQint8 
+#dequantize_op_test.DequantizeOpTest.testBasicQint8
+
+
+# Note that all these test will pass on CPU (except testUInt32AndUInt64), because on CPU gather falls back to TF
+# In case of NNPI all except the last pass. But CI wont be tracking it because CI runs on CPU backend only
+gather_op_test.GatherTest.testBadAxis
+gather_op_test.GatherTest.testBadIndicesCPU
+#gather_op_test.GatherTest.testEmptySlices  ...failure in backend due to int64
+#gather_op_test.GatherTest.testScalar1D ...failure in backend due to int64
+#gather_op_test.GatherTest.testScalar2D ...failure in backend due to int64
+#gather_op_test.GatherTest.testSimpleTwoD32 ...failure in backend due to int64
+gather_op_test.GatherTest.testString
+#gather_op_test.GatherTest.testUInt32AndUInt64  ...Unsupported TensorFlow data type: DT_UINT32
+gather_op_test.GatherTest.testUnknownAxis
+gather_op_test.GatherTest.testUnknownIndices
+gather_op_test.GatherTest.test_session
+#gather_op_test.GatherTest.testHigherRank ..ERROR
+
+# This test set fails on NNPI
+#batch_gather_op_test
 
 identity_n_op_py_test.IdentityNOpTest.testInt32String_6 
 identity_n_op_py_test.IdentityNOpTest.testInt32_shapes