[Tensor] Change init so it doesn't touch fused scale/offset.

Author: jfix71

include/glow/Base/Tensor.h

@@ -107,6 +107,18 @@ class Tensor final {
       auto *data = reinterpret_cast<int32_t *>(getData());
       std::fill(&data[0], &data[0] + size(), (int32_t)type_.getOffset());
     } break;
+    case ElemKind::Int8FusedQTy: {
+      assert(dims().size() == 2 && "Fused tensor must be 2-dimensional.");
+      assert(dims()[1] > 8 && "Fused tensor must have more than 8 columns.");
+      const size_t width = dims()[1];
+      auto *data = reinterpret_cast<int8_t *>(getData());
+      for (size_t i = 0, e = dims()[0]; i < e; i++) {
+        int8_t *scaleOffsetPtr = &data[(i + 1) * width] - 8;
+        int32_t offset;
+        memcpy(&offset, scaleOffsetPtr + 4, 4);
+        std::fill(&data[i * width], scaleOffsetPtr, (int8_t)offset);
+      }
+    } break;
     default:
       // Non-quantized tensors are set to 0.
       std::fill(&getData()[0], &getData()[0] + size() * type_.getElementSize(),
@@ -174,8 +186,9 @@ class Tensor final {
   Tensor &operator=(const Tensor &other) = delete;
 
   /// Initialize the content of the tensor using the \p init method. The value
-  /// \p val is the initialization parameter. \p PRNG is used to generate
-  /// random numbers.
+  /// \p val is the initialization parameter. \p PRNG is used to generate random
+  /// numbers. Note that if the tensor's kind is Int8FusedQTy, then the fused
+  /// scaled/offsets will not be modified.
   void init(InitKind init, float val, PseudoRNG &PRNG);
 
   /// \returns unowned tensor using the same data buffer as the current tensor
@@ -717,8 +730,23 @@ template <class ElemTy> class Handle final {
     assert(filterSize > 0 && "invalid filter size");
     double scale = std::sqrt(3.0 / double(filterSize));
     std::uniform_real_distribution<> dist(-scale, scale);
-    for (auto &e : *this) {
-      e = dist(PRNG);
+    switch (getElementType()) {
+    default: {
+      for (auto &e : *this) {
+        e = dist(PRNG);
+      }
+      return;
+    }
+    case ElemKind::Int8FusedQTy: {
+      assert(dims().size() == 2 && "Fused tensor must be 2-dimensional.");
+      assert(dims()[1] > 8 && "Fused tensor must have more than 8 columns.");
+      for (size_t i = 0, e = dims()[0]; i < e; i++) {
+        for (size_t j = 0, f = dims()[1] - 8; j < f; j++) {
+          at({i, j}) = dist(PRNG);
+        }
+      }
+      return;
+    }
     }
   }
 

lib/Base/Tensor.cpp

@@ -423,7 +423,14 @@ void Tensor::init(InitKind init, float val, PseudoRNG &PRNG) {
       break;
     }
     case ElemKind::Int8FusedQTy: {
-      getHandle<int8_t>().clear(val);
+      assert(dims().size() == 2 && "Fused tensor must be 2-dimensional.");
+      assert(dims()[1] > 8 && "Fused tensor must have more than 8 columns.");
+      auto H = getHandle<int8_t>();
+      for (size_t i = 0; i < dims()[0]; i++) {
+        for (size_t j = 0, f = dims()[1] - 8; j < f; j++) {
+          H.at({i, j}) = val;
+        }
+      }
       break;
     }
     }

tests/unittests/TensorsTest.cpp

@@ -791,3 +791,80 @@ TEST(Tensor, insertSlice) {
                             3.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f};
   EXPECT_TRUE(big.isEqual(expected));
 }
+
+/// Check that after initializing a fused tensor to zero that the scale and
+/// offset are not changed and that the values for each row are set to that
+/// row's offset.
+TEST(Tensor, initZeroFused) {
+  Tensor T(ElemKind::Int8FusedQTy, {10, 10}, 0.0, 0);
+  auto TH = T.getHandle<int8_t>();
+  TH.clear(127);
+  for (size_t i = 0; i < 10; i++) {
+    for (size_t j = 2; j < 10; j++) {
+      // Set 6 due to endianess when loading the int32_t offset.
+      if (j == 6) {
+        TH.at({i, j}) = i + 100;
+      } else {
+        TH.at({i, j}) = 0;
+      }
+    }
+  }
+  PseudoRNG PRNG;
+  T.init(Tensor::InitKind::Zero, 1, PRNG);
+  for (size_t i = 0; i < 10; i++) {
+    for (size_t j = 0; j < 10; j++) {
+      // Now check that both the offset and the values are correct, and that all
+      // other values are still 0.
+      if (j < 2 || j == 6) {
+        EXPECT_EQ(TH.at({i, j}), i + 100);
+      } else {
+        EXPECT_EQ(TH.at({i, j}), 0);
+      }
+    }
+  }
+}
+
+/// Check that initializing a fused tensor with Xavier that the scale and offset
+/// are not changed.
+TEST(Tensor, initXavierFused) {
+  Tensor T(ElemKind::Int8FusedQTy, {10, 10}, 0.0, 0);
+  PseudoRNG PRNG;
+  auto TH = T.getHandle<int8_t>();
+  for (size_t i = 0; i < 10; i++) {
+    for (size_t j = 0; j < 10; j++) {
+      TH.at({i, j}) = i * 10 + j;
+    }
+  }
+  T.init(Tensor::InitKind::Xavier, 1, PRNG);
+  for (size_t i = 0; i < 10; i++) {
+    for (size_t j = 2; j < 10; j++) {
+      // Check that the scales/offsets are unchanged.
+      EXPECT_EQ(TH.at({i, j}), i * 10 + j);
+    }
+  }
+}
+
+/// Check that initializing a fused tensor with Broadcast that the scale and
+/// offset are not changed, and broadcast value is set correctly.
+TEST(Tensor, initBroadcastFused) {
+  Tensor T(ElemKind::Int8FusedQTy, {10, 10}, 0.0, 0);
+  auto TH = T.getHandle<int8_t>();
+  for (size_t i = 0; i < 10; i++) {
+    for (size_t j = 0; j < 10; j++) {
+      TH.at({i, j}) = i * 10 + j;
+    }
+  }
+  PseudoRNG PRNG;
+  T.init(Tensor::InitKind::Broadcast, 5, PRNG);
+  for (size_t i = 0; i < 10; i++) {
+    for (size_t j = 0; j < 10; j++) {
+      // Check that the scales/offsets are unchanged, and that the broadcast
+      // value is everywhere else.
+      if (j < 2) {
+        EXPECT_EQ(TH.at({i, j}), 5);
+      } else {
+        EXPECT_EQ(TH.at({i, j}), i * 10 + j);
+      }
+    }
+  }
+}