[ Tensor ] Support NHWC for dot, add/multiply_strided and other ops

This PR includes changes of Tensor and TensorDim to support NHWC
computation for dot, add_strided, multiply_strided, cat, split,
and transpose. It also includes unittests to evaluate.

**Self evaluation:**
1. Build test:	 [X]Passed [ ]Failed [ ]Skipped
2. Run test:	 [X]Passed [ ]Failed [ ]Skipped

Signed-off-by: Adwaith Anand <adwaith.a@samsung.com>
Signed-off-by: Manohara HK <manohara.hk@samsung.com>
Signed-off-by: jijoong.moon <jijoong.moon@samsung.com>

diff --git a/nntrainer/tensor/tensor.cpp b/nntrainer/tensor/tensor.cpp
index 1eea5d4..abf448d 100644 (file)
--- a/nntrainer/tensor/tensor.cpp
+++ b/nntrainer/tensor/tensor.cpp
@@ -54,6 +54,27 @@
           }                                                           \
   } while (0);
 
+
+#define transposeloop_nhwc(cl, ci, cj, ck, sl, si, sj, sk)            \
+  do {                                                                \
+    unsigned int i, j, k, l;                                          \
+    int inidx = 0, outidx = 0;                                        \
+    for (cl = 0; cl < sl; cl++)                                       \
+      for (ci = 0; ci < si; ci++)                                     \
+        for (cj = 0; cj < sj; cj++)                                   \
+          for (ck = 0; ck < sk; ck++) {                               \
+            outidx = si * sj * sk * cl + sj * sk * ci + sk * cj + ck; \
+            inidx = l * SJ * SK * SI + j * SK * SI + k * SI + i;      \
+            outptr[outidx] = inptr[inidx];                            \
+          }                                                           \
+  } while (0);
+
+#define CREATE_IF_EMPTY_DIMS(tensor, ...) \
+  do {                                    \
+    if (tensor.empty()) {                 \
+      tensor = Tensor(__VA_ARGS__);       \
+    }                                     \
+  } while (0);
 namespace nntrainer {
 
 /**
@@ -85,7 +106,7 @@ struct Tensor::BroadcastInfo {
 
 Tensor::Tensor(const TensorDim &d, bool alloc_now, Tensor::Initializer init,
                std::string name_) :
-  Tensor(name_) {
+  Tensor(name_, d.getFormat()) {
   if (d.getDataLen() != 0) {
     dim = d;
     strides = d.computeStrides();
@@ -149,6 +170,7 @@ void Tensor::allocate() {
     /** as this memory is shared, do NOT initialize */
   } else {
     /// allocate new memory for the tensor data
+
     MemoryData *mem_data;
 
     if (getDataType() == ml::train::TensorDim::DataType::FP32) {
@@ -302,65 +324,137 @@ Tensor Tensor::multiply_strided(Tensor const &m, const float beta) const {
 Tensor &Tensor::multiply_strided(Tensor const &m, Tensor &output,
                                  const float beta) const {
   /** TODO: throw than create new dimenions */
-  CREATE_IF_EMPTY_DIMS(output, dim, nullptr);
+  CREATE_IF_EMPTY_DIMS(output, dim, nullptr, data_type);
 
   if (size() != m.size() || size() != output.size())
     throw std::invalid_argument(
       "Strided multiplication does not support broadcasting");
   if (dim.getDataType() == ml::train::TensorDim::DataType::FP32) {
-    if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
-        beta != 0.0) {
-      for (unsigned int b = 0; b < batch(); ++b) {
-        for (unsigned int c = 0; c < channel(); ++c) {
-          for (unsigned int h = 0; h < height(); ++h) {
-            for (unsigned int w = 0; w < width(); ++w) {
-              output.addValue(b, c, h, w,
-                              getValue<float>(b, c, h, w) *
-                                m.getValue<float>(b, c, h, w),
-                              beta);
+  NNTR_THROW_IF(getData() == nullptr, std::invalid_argument)
+    << getName() << " is not allocated";
+  NNTR_THROW_IF(m.getData() == nullptr, std::invalid_argument)
+    << m.getName() << " is not allocated";
+  NNTR_THROW_IF(output.getData() == nullptr, std::invalid_argument)
+    << output.getName() << " is not allocated";
+
+  // Format NCHW Case
+  if (this->getFormat() == Tformat::NCHW) {
+    if (getDataType() == DataType::FP32) {
+      if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
+          beta != 0.0) {
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int c = 0; c < channel(); ++c) {
+            for (unsigned int h = 0; h < height(); ++h) {
+              for (unsigned int w = 0; w < width(); ++w) {
+                output.addValue(b, c, h, w,
+                                getValue<float>(b, c, h, w) *
+                                  m.getValue<float>(b, c, h, w),
+                                beta);
+              }
+            }
+          }
+        }
+      } else {
+        /** @todo optimize this with combining these loops where stride is 1 */
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int c = 0; c < channel(); ++c) {
+            for (unsigned int h = 0; h < height(); ++h) {
+              float *out_data = output.getAddress<float>(b, c, h, 0);
+              const float *m_data = m.getAddress<float>(b, c, h, 0);
+              const float *in_data = getAddress<float>(b, c, h, 0);
+              std::transform(in_data, in_data + width(), m_data, out_data,
+                             std::multiplies<float>());
             }
           }
         }
       }
-    } else {
-      /** @todo optimize this with combining these loops where stride is 1 */
-      for (unsigned int b = 0; b < batch(); ++b) {
-        for (unsigned int c = 0; c < channel(); ++c) {
-          for (unsigned int h = 0; h < height(); ++h) {
-            float *out_data = output.getAddress(b, c, h, 0);
-            const float *m_data = m.getAddress(b, c, h, 0);
-            const float *in_data = getAddress(b, c, h, 0);
-            std::transform(in_data, in_data + width(), m_data, out_data,
-                           std::multiplies<float>());
+    } else if (dim.getDataType() == ml::train::TensorDim::DataType::FP16) {
+      if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
+          beta != 0.0) {
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int c = 0; c < channel(); ++c) {
+            for (unsigned int h = 0; h < height(); ++h) {
+              for (unsigned int w = 0; w < width(); ++w) {
+                output.addValue(b, c, h, w,
+                                getValue<__fp16>(b, c, h, w) *
+                                  m.getValue<__fp16>(b, c, h, w),
+                                beta);
+              }
+            }
+          }
+        }
+      } else {
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int c = 0; c < channel(); ++c) {
+            for (unsigned int h = 0; h < height(); ++h) {
+              float *out_data = output.getAddress<float>(b, c, h, 0);
+              const float *m_data = m.getAddress<float>(b, c, h, 0);
+              const float *in_data = getAddress<float>(b, c, h, 0);
+              std::transform(in_data, in_data + width(), m_data, out_data,
+                             std::multiplies<__fp16>());
+            }
           }
         }
       }
     }
-  } else if (dim.getDataType() == ml::train::TensorDim::DataType::FP16) {
-    if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
-        beta != 0.0) {
-      for (unsigned int b = 0; b < batch(); ++b) {
-        for (unsigned int c = 0; c < channel(); ++c) {
+  } else { // Format NHWC Case
+    if (getDataType() == DataType::FP32) {
+      if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
+          beta != 0.0) {
+        for (unsigned int b = 0; b < batch(); ++b) {
           for (unsigned int h = 0; h < height(); ++h) {
             for (unsigned int w = 0; w < width(); ++w) {
-              output.addValue(b, c, h, w,
-                              getValue<__fp16>(b, c, h, w) *
-                                m.getValue<__fp16>(b, c, h, w),
-                              beta);
+              for (unsigned int c = 0; c < channel(); ++c) {
+                output.addValue(b, c, h, w,
+                                getValue<float>(b, c, h, w) *
+                                  m.getValue<float>(b, c, h, w),
+                                beta);
+              }
+            }
+          }
+        }
+      } else {
+        /** @todo optimize this with combining these loops where
+         * stride is 1 */
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int h = 0; h < height(); ++h) {
+            for (unsigned int w = 0; w < width(); ++w) {
+              float *out_data = output.getAddress<float>(b, c, h, 0);
+              const float *m_data = m.getAddress<float>(b, c, h, 0);
+              const float *in_data = getAddress<float>(b, c, h, 0);
+              std::transform(in_data, in_data + channel(), m_data, out_data,
+                             std::multiplies<float>());
             }
           }
         }
       }
-    } else {
-      /** @todo optimize this with combining these loops where stride is 1 */
-      for (unsigned int b = 0; b < batch(); ++b) {
-        for (unsigned int c = 0; c < channel(); ++c) {
+    } else if (getDataType() == ml::train::TensorDim::DataType::FP16) {
+      if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
+          beta != 0.0) {
+        for (unsigned int b = 0; b < batch(); ++b) {
           for (unsigned int h = 0; h < height(); ++h) {
-            __fp16 *out_data = output.getAddress<__fp16>(b, c, h, 0);
-            const __fp16 *m_data = m.getAddress<__fp16>(b, c, h, 0);
-            const __fp16 *in_data = getAddress<__fp16>(b, c, h, 0);
-            std::transform(in_data, in_data + width(), m_data, out_data,
-                           std::multiplies<__fp16>());
+            for (unsigned int w = 0; w < width(); ++w) {
+              for (unsigned int c = 0; c < channel(); ++c) {
+                output.addValue(b, c, h, w,
+                                getValue<__fp16>(b, c, h, w) *
+                                  m.getValue<__fp16>(b, c, h, w),
+                                beta);
+              }
+            }
+          }
+        }
+      } else {
+        /** @todo optimize this with combining these loops where
+         * stride is 1 */
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int h = 0; h < height(); ++h) {
+            for (unsigned int w = 0; w < width(); ++w) {
+              __fp16 *out_data = output.getAddress<__fp16>(b, c, h, 0);
+              const __fp16 *m_data = m.getAddress<__fp16>(b, c, h, 0);
+              const __fp16 *in_data = getAddress<__fp16>(b, c, h, 0);
+              std::transform(in_data, in_data + channel(), m_data, out_data,
+                             std::multiplies<__fp16>());
+            }
           }
         }
       }
@@ -394,58 +488,121 @@ Tensor &Tensor::add_strided(Tensor const &m, Tensor &output,
   if (size() != m.size() || size() != output.size())
     throw std::invalid_argument(
       "Strided addition does not support broadcasting");
-  if (dim.getDataType() == ml::train::TensorDim::DataType::FP32) {
-    if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
-        beta != 0.0) {
-      for (unsigned int b = 0; b < batch(); ++b) {
-        for (unsigned int c = 0; c < channel(); ++c) {
-          for (unsigned int h = 0; h < height(); ++h) {
-            for (unsigned int w = 0; w < width(); ++w) {
-              output.setValue(b, c, h, w,
-                              getValue<float>(b, c, h, w) +
-                                m.getValue<float>(b, c, h, w) * beta);
+  // Format NCHW Case
+  if (this->getFormat() == Tformat::NCHW) {
+    if (getDataType() == DataType::FP32) {
+      if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
+          beta != 0.0) {
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int c = 0; c < channel(); ++c) {
+            for (unsigned int h = 0; h < height(); ++h) {
+              for (unsigned int w = 0; w < width(); ++w) {
+                output.setValue(b, c, h, w,
+                                getValue<float>(b, c, h, w) +
+                                  m.getValue<float>(b, c, h, w) * beta);
+              }
+            }
+          }
+        }
+      } else {
+        /** @todo optimize this with combining these loops where stride is 1 */
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int c = 0; c < channel(); ++c) {
+            for (unsigned int h = 0; h < height(); ++h) {
+              float *out_data = output.getAddress<float>(b, c, h, 0);
+              const float *m_data = m.getAddress<float>(b, c, h, 0);
+              const float *in_data = getAddress<float>(b, c, h, 0);
+              std::transform(in_data, in_data + width(), m_data, out_data,
+                             std::plus<float>());
             }
           }
         }
       }
-    } else {
-      /** @todo optimize this with combining these loops where stride is 1 */
-      for (unsigned int b = 0; b < batch(); ++b) {
-        for (unsigned int c = 0; c < channel(); ++c) {
-          for (unsigned int h = 0; h < height(); ++h) {
-            float *out_data = output.getAddress<float>(b, c, h, 0);
-            const float *m_data = m.getAddress<float>(b, c, h, 0);
-            const float *in_data = getAddress<float>(b, c, h, 0);
-            std::transform(in_data, in_data + width(), m_data, out_data,
-                           std::plus<float>());
+    } else if (dim.getDataType() == ml::train::TensorDim::DataType::FP16) {
+      if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
+          beta != 0.0) {
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int c = 0; c < channel(); ++c) {
+            for (unsigned int h = 0; h < height(); ++h) {
+              for (unsigned int w = 0; w < width(); ++w) {
+                output.setValue(b, c, h, w,
+                                getValue<__fp16>(b, c, h, w) +
+                                  m.getValue<__fp16>(b, c, h, w) * beta);
+              }
+            }
+          }
+        }
+      } else {
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int c = 0; c < channel(); ++c) {
+            for (unsigned int h = 0; h < height(); ++h) {
+              __fp16 *out_data = output.getAddress<__fp16>(b, c, h, 0);
+              const __fp16 *m_data = m.getAddress<__fp16>(b, c, h, 0);
+              const __fp16 *in_data = getAddress<__fp16>(b, c, h, 0);
+              std::transform(in_data, in_data + width(), m_data, out_data,
+                             std::plus<__fp16>());
+            }
           }
         }
       }
     }
-  } else if (dim.getDataType() == ml::train::TensorDim::DataType::FP16) {
-    if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
-        beta != 0.0) {
-      for (unsigned int b = 0; b < batch(); ++b) {
-        for (unsigned int c = 0; c < channel(); ++c) {
+  } else { // Format NHWC Case
+    if (getDataType() == DataType::FP32) {
+      if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
+          beta != 0.0) {
+        for (unsigned int b = 0; b < batch(); ++b) {
           for (unsigned int h = 0; h < height(); ++h) {
             for (unsigned int w = 0; w < width(); ++w) {
-              output.setValue(b, c, h, w,
-                              getValue<__fp16>(b, c, h, w) +
-                                m.getValue<__fp16>(b, c, h, w) * beta);
+              for (unsigned int c = 0; c < channel(); ++c) {
+                output.setValue(b, c, h, w,
+                                getValue<float>(b, c, h, w) +
+                                  m.getValue<float>(b, c, h, w) * beta);
+              }
+            }
+          }
+        }
+      } else {
+        /** @todo optimize this with combining these loops where
+         * stride is 1 */
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int h = 0; h < height(); ++h) {
+            for (unsigned int w = 0; w < width(); ++w) {
+              float *out_data = output.getAddress<float>(b, c, h, 0);
+              const float *m_data = m.getAddress<float>(b, c, h, 0);
+              const flaot *in_data = getAddress<float>(b, c, h, 0);
+              std::transform(in_data, in_data + channel(), m_data, out_data,
+                             std::plus<float>());
             }
           }
         }
       }
-    } else {
-      /** @todo optimize this with combining these loops where stride is 1 */
-      for (unsigned int b = 0; b < batch(); ++b) {
-        for (unsigned int c = 0; c < channel(); ++c) {
+    } else if (getDataType() == ml::train::TensorDim::DataType::FP16) {
+      if (strides[3] != 1 || m.strides[3] != 1 || output.strides[3] != 1 ||
+          beta != 0.0) {
+        for (unsigned int b = 0; b < batch(); ++b) {
           for (unsigned int h = 0; h < height(); ++h) {
-            __fp16 *out_data = output.getAddress<__fp16>(b, c, h, 0);
-            const __fp16 *m_data = m.getAddress<__fp16>(b, c, h, 0);
-            const __fp16 *in_data = getAddress<__fp16>(b, c, h, 0);
-            std::transform(in_data, in_data + width(), m_data, out_data,
-                           std::plus<__fp16>());
+            for (unsigned int w = 0; w < width(); ++w) {
+              for (unsigned int c = 0; c < channel(); ++c) {
+                output.setValue(b, c, h, w,
+                                getValue<__fp16>(b, c, h, w) *
+                                  m.getValue<__fp16>(b, c, h, w),
+                                beta);
+              }
+            }
+          }
+        }
+      } else {
+        /** @todo optimize this with combining these loops where
+         * stride is 1 */
+        for (unsigned int b = 0; b < batch(); ++b) {
+          for (unsigned int h = 0; h < height(); ++h) {
+            for (unsigned int w = 0; w < width(); ++w) {
+              __fp16 *out_data = output.getAddress<__fp16>(b, c, h, 0);
+              const __fp16 *m_data = m.getAddress<__fp16>(b, c, h, 0);
+              const __fp16 *in_data = getAddress<__fp16>(b, c, h, 0);
+              std::transform(in_data, in_data + channel(), m_data, out_data,
+                             std::plus<__fp16>());
+            }
           }
         }
       }
@@ -529,12 +686,22 @@ Tensor &Tensor::multiply(Tensor const &m, Tensor &output,
       }
     };
 
+    NNTR_THROW_IF(m.getFormat() != this->getFormat(), std::invalid_argument)
+      << "Tensor Format of " << getName() << ":"
+      << ((bool)(this->getFormat()) ? "NHWC" : "NCHW") << " is not match. ("
+      << ((bool)(m.getFormat()) ? "NHWC" : "NCHW") << ")";
+
+    NNTR_THROW_IF(!contiguous || !m.contiguous || !output.contiguous,
+                  std::invalid_argument)
+      << getName() << " is not contiguous, cannot multiply";
+
     NNTR_THROW_IF(!contiguous || !m.contiguous || !output.contiguous,
                   std::invalid_argument)
       << getName() << " is not contiguous, cannot multiply";
 
     apply_broadcast(m, f, output);
     return output;
+    
   } else if (dim.getDataType() == ml::train::TensorDim::DataType::FP16) {
     auto f = [&](const BroadcastInfo &e, const __fp16 *buf, const __fp16 *m_buf,
                  __fp16 *out_buf) {
@@ -552,6 +719,11 @@ Tensor &Tensor::multiply(Tensor const &m, Tensor &output,
       }
     };
 
+    NNTR_THROW_IF(m.getFormat() != this->getFormat(), std::invalid_argument)
+      << "Tensor Format of " << getName() << ":"
+      << ((bool)(this->getFormat()) ? "NHWC" : "NCHW") << " is not match. ("
+      << ((bool)(m.getFormat()) ? "NHWC" : "NCHW") << ")";
+
     NNTR_THROW_IF(!contiguous || !m.contiguous || !output.contiguous,
                   std::invalid_argument)
       << getName() << " is not contiguous, cannot multiply";
@@ -962,10 +1134,15 @@ Tensor Tensor::cat(const std::vector<Tensor> &tensors, int axis) {
                                   [axis](unsigned cur, const Tensor &t) {
                                     return cur += t.getDim().getTensorDim(axis);
                                   });
-  auto iter_value = [](std::array<unsigned, 4> &loc,
-                       std::array<unsigned, 4> &start_loc, Tensor &t,
-                       const TensorDim &ref_dim) -> float & {
-    auto &value = t.getValue<float>(loc[0], loc[1], loc[2], loc[3]);
+  auto iter_value =
+    [is_format_nchw](std::array<unsigned, 4> &loc,
+                     const std::array<unsigned, 4> &start_loc, Tensor &t,
+                     const std::array<unsigned, 4> &ref_dim_arr) -> float & {
+      
+    auto &value = is_format_nchw
+                    ? t.getValue<float>(loc[0], loc[1], loc[2], loc[3])
+                    : t.getValue<float>(loc[0], loc[3], loc[1], loc[2]);
+    
     for (int i = 3; i >= 0; --i) {
       loc[i]++;
       if (loc[i] - start_loc[i] == ref_dim_arr[i]) {
@@ -999,7 +1176,19 @@ Tensor Tensor::cat(const std::vector<Tensor> &tensors, int axis) {
     }
 
     for (size_t i = 0u, sz = t.size(); i < sz; ++i) {
-      iter_value(loc, start_loc, ret, t.getDim()) = t.getValue<float>(i);
+      iter_value(loc, start_loc, ret, tensor_dim_arr) = t.getValue<float>(i);
+    }
+
+    if (is_format_nchw) {
+      loc[axis] += t.getDim().getTensorDim(axis);
+    } else {
+      if (axis == 0) {
+        loc[0] += t.getDim().getTensorDim(axis);
+      } else if (axis == 1) {
+        loc[3] += t.getDim().getTensorDim(axis);
+      } else if (axis == 2 || axis == 3) {
+        loc[axis - 1] += t.getDim().getTensorDim(axis);
+      }
     }
   }
 
@@ -1197,46 +1386,81 @@ Tensor &Tensor::sum(unsigned int axis, Tensor &ret, float alpha,
           ones.getData(), 1, beta, ret.getData(), 1);
   } break;
   case 1: {
-    CREATE_IF_EMPTY_DIMS(ret, dim.batch(), 1, dim.height(), dim.width(),
-                         getTensorType());
-    unsigned int feat_len = dim.height() * dim.width();
-    unsigned int channel = dim.channel();
-    Tensor ones(1, 1, 1, channel);
-    ones.setValue(alpha);
-    float *rdata = ret.getData<float>();
-    for (unsigned int k = 0; k < dim.batch(); ++k) {
-      sgemv(CblasRowMajor, CblasTrans, channel, feat_len, 1,
-            &data[k * dim.getFeatureLen()], feat_len, ones.getData(), 1, beta,
-            &rdata[k * feat_len], 1);
+    CREATE_IF_EMPTY_DIMS(ret, dim[0], 1, dim[2], dim[3], getTensorType());
+    if (this->getFormat() == Tformat::NHWC) {
+      unsigned int m = ret.dim.getDataLen();
+      unsigned int n = dim[1];
+      Tensor ones(1, 1, 1, n, this->getTensorType());
+      ones.setValue(alpha);
+      sgemv(CblasRowMajor, CblasNoTrans, m, n, 1, data, n,
+            ones.getData<float>(), 1, beta, ret.getData<float>(), 1);
+    } else {
+      unsigned int feat_len = dim[2] * dim[3];
+      unsigned int t_axis = dim[1];
+      Tensor ones(1, 1, 1, t_axis, getTensorType());
+      ones.setValue(alpha);
+      float *rdata = ret.getData<float>();
+      for (unsigned int k = 0; k < dim[0]; ++k) {
+        sgemv(CblasRowMajor, CblasTrans, t_axis, feat_len, 1,
+              &data[k * dim.getFeatureLen()], feat_len, ones.getData<float>(), 1, beta,
+              &rdata[k * feat_len], 1);
+      }
     }
   } break;
   case 2: {
-    CREATE_IF_EMPTY_DIMS(ret, dim.batch(), dim.channel(), 1, dim.width(),
-                         getTensorType());
-    unsigned int width = dim.width();
-    unsigned int height = dim.height();
-    Tensor ones(1, 1, 1, height);
-    ones.setValue(alpha);
-    float *rdata = ret.getData<float>();
-    for (unsigned int k = 0; k < dim.batch(); ++k) {
-      for (unsigned int c = 0; c < dim.channel(); ++c) {
-        unsigned int idx =
-          k * dim.getFeatureLen() + c * dim.width() * dim.height();
-        unsigned int ridx = k * ret.dim.getFeatureLen() + c * dim.width();
-        sgemv(CblasRowMajor, CblasTrans, height, width, 1, &data[idx], width,
-              ones.getData(), 1, beta, &rdata[ridx], 1);
+    CREATE_IF_EMPTY_DIMS(ret, dim[0], dim[1], 1, dim[3], getTensorType());
+
+    if (this->getFormat() == Tformat::NHWC) {
+      unsigned int feat_len = dim[1] * dim[3];
+      unsigned int t_axis = dim[2];
+      Tensor ones(1, 1, 1, t_axis, this->getTensorType());
+      ones.setValue(alpha);
+      float *rdata = ret.getData<float>();
+      for (unsigned int k = 0; k < dim[0]; ++k) {
+        sgemv(CblasRowMajor, CblasTrans, t_axis, feat_len, 1,
+              &data[k * dim.getFeatureLen()], feat_len, ones.getData<float>(),
+              1, beta, &rdata[k * feat_len], 1);
+      }
+    } else {
+      unsigned int t_3 = dim[3];
+      unsigned int t_axis = dim[2];
+      Tensor ones(1, 1, 1, t_axis, this->getTensorType());
+      ones.setValue(alpha);
+      float *rdata = ret.getData<float>();
+      for (unsigned int k = 0; k < dim[0]; ++k) {
+        for (unsigned int c = 0; c < dim[1]; ++c) {
+          unsigned int idx = k * dim.getFeatureLen() + c * dim[3] * dim[2];
+          unsigned int ridx = k * ret.dim.getFeatureLen() + c * dim[3];
+          sgemv(CblasRowMajor, CblasTrans, t_axis, t_3, 1, &data[idx], t_3,
+                ones.getData<float>(), 1, beta, &rdata[ridx], 1);
+        }
       }
     }
   } break;
   case 3: {
-    CREATE_IF_EMPTY_DIMS(ret, dim.batch(), dim.channel(), dim.height(), 1,
-                         getTensorType());
-    unsigned int m = ret.dim.getDataLen();
-    unsigned int n = dim.width();
-    Tensor ones(1, 1, 1, n);
-    ones.setValue(alpha);
-    sgemv(CblasRowMajor, CblasNoTrans, m, n, 1, data, n, ones.getData<float>(),
-          1, beta, ret.getData<float>(), 1);
+    CREATE_IF_EMPTY_DIMS(ret, dim[0], dim[1], dim[2], 1, this->getTensorType());
+    if (this->getFormat() == Tformat::NHWC) {
+      unsigned int t_3 = dim[1];
+      unsigned int t_axis = dim[3];
+      Tensor ones(1, 1, 1, t_axis, this->getTensorType());
+      ones.setValue(alpha);
+      float *rdata = ret.getData<float>();
+      for (unsigned int k = 0; k < dim[0]; ++k) {
+        for (unsigned int c = 0; c < dim[2]; ++c) {
+          unsigned int idx = k * dim.getFeatureLen() + c * dim[3] * dim[1];
+          unsigned int ridx = k * ret.dim.getFeatureLen() + c * dim[1];
+          sgemv(CblasRowMajor, CblasTrans, t_axis, t_3, 1, &data[idx], t_3,
+                ones.getData<float>(), 1, beta, &rdata[ridx], 1);
+        }
+      }
+    } else {
+      unsigned int m = ret.dim.getDataLen();
+      unsigned int n = dim[3];
+      Tensor ones(1, 1, 1, n);
+      ones.setValue(alpha);
+      sgemv(CblasRowMajor, CblasNoTrans, m, n, 1, data, n, ones.getData(), 1,
+            beta, ret.getData(), 1);
+    }
   } break;
   default:
     throw std::out_of_range("Error: Dimension cannot exceed 3");
@@ -1425,8 +1649,13 @@ Tensor &Tensor::dot(Tensor const &m, Tensor &result, bool trans, bool trans_m,
     K = mdim1; /** == dim2 */
     N = mdim2;
     M = dim1;
-    CREATE_IF_EMPTY_DIMS(result, batch(), channel(), height(), N,
-                         getTensorType());
+    if (getFormat() == Tformat::NHWC) {
+      CREATE_IF_EMPTY_DIMS(result, batch(), N, height(), width(),
+                           getTensorType()); //  NHWC Result Tensor
+    } else {
+      CREATE_IF_EMPTY_DIMS(result, batch(), channel(), height(), N,
+                           getTensorType());
+    }
 
     // We are not set zero the result because of performnace reason.
     // However, result is not initialized properly. There might include
@@ -1440,8 +1669,17 @@ Tensor &Tensor::dot(Tensor const &m, Tensor &result, bool trans, bool trans_m,
     K = mdim2; /** == dim2 */
     N = mdim1;
     M = dim1;
-    CREATE_IF_EMPTY_DIMS(result, batch(), channel(), height(), N,
-                         getTensorType());
+    if (getFormat() == Tformat::NHWC) {
+      CREATE_IF_EMPTY_DIMS(result, batch(), N, height(), width(),
+                           getTensorType());
+    } else {
+      CREATE_IF_EMPTY_DIMS(result, batch(), channel(), height(), N,
+                           getTensorType());
+      CREATE_IF_EMPTY_DIMS(result, batch(), channel(), height(), N,
+                           getTensorType());
+      CREATE_IF_EMPTY_DIMS(result, batch(), channel(), height(), N,
+                           getTensorType());
+    }
   } else if (trans && !trans_m) {
     if (dim1 != mdim1)
       throw std::runtime_error(
@@ -1449,7 +1687,11 @@ Tensor &Tensor::dot(Tensor const &m, Tensor &result, bool trans, bool trans_m,
     K = mdim1; /** == dim1 */
     N = mdim2;
     M = dim2;
-    CREATE_IF_EMPTY_DIMS(result, 1, 1, M, N, getTensorType());
+    if (getFormat() == Tformat::NHWC) {
+      CREATE_IF_EMPTY_DIMS(result, 1, N, M, 1, getTensorType());
+    } else {
+      CREATE_IF_EMPTY_DIMS(result, 1, 1, M, N, getTensorType());
+    }
   } else {
     if (dim1 != mdim2)
       throw std::runtime_error(
@@ -1457,7 +1699,11 @@ Tensor &Tensor::dot(Tensor const &m, Tensor &result, bool trans, bool trans_m,
     K = mdim2; /** == dim1 */
     N = mdim1;
     M = dim2;
-    CREATE_IF_EMPTY_DIMS(result, 1, 1, M, N, getTensorType());
+    if (getFormat() == Tformat::NHWC) {
+      CREATE_IF_EMPTY_DIMS(result, 1, N, M, 1,  getTensorType());
+    } else {
+      CREATE_IF_EMPTY_DIMS(result, 1, 1, M, N, getTensorType());
+    }
   }
   lda = dim2;
   ldb = mdim2;
@@ -1709,7 +1955,7 @@ Tensor &Tensor::apply(std::function<Tensor &(Tensor, Tensor &)> f,
 void Tensor::print(std::ostream &out) const {
   printInstance(out, this);
   if (getDataType() == ml::train::TensorDim::DataType::FP32) {
-    const __fp16 *data = getData<__fp16>();
+    const float *data = getData<float>();
     unsigned int len = size();
     out << "data addr: " << data << '\n';
     out << dim;
@@ -1723,24 +1969,36 @@ void Tensor::print(std::ostream &out) const {
 
     std::ios init(NULL);
     init.copyfmt(out);
-    for (unsigned int k = 0; k < dim.batch(); k++) {
-      for (unsigned int l = 0; l < dim.channel(); l++) {
-        for (unsigned int i = 0; i < dim.height(); i++) {
-          for (unsigned int j = 0; j < dim.width(); j++) {
-            out << std::setw(10) << std::setprecision(10)
-                << this->getValue<float>(k, l, i, j) << " ";
+    if (getFormat() == Tformat::NCHW) {
+      for (unsigned int k = 0; k < batch(); k++) {
+        for (unsigned int l = 0; l < channel(); l++) {
+          for (unsigned int i = 0; i < height(); i++) {
+            for (unsigned int j = 0; j < width(); j++) {
+              out << std::setw(10) << std::setprecision(10)
+                  << this->getValue<float>(k, l, i, j) << " ";
+            }
+            out << std::endl;
           }
           out << std::endl;
         }
-        if (k < batch() - 1)
-          out << "},";
-        else
-          out << "}";
-        out << std::endl;
+        out << "-------" << std::endl;
       }
-      out << "-------" << std::endl;
+    } else {
+      for (unsigned int k = 0; k < batch(); k++) {
+        for (unsigned int i = 0; i < height(); i++) {
+          for (unsigned int j = 0; j < width(); j++) {
+            for (unsigned int l = 0; l < channel(); l++) {
+              out << std::setw(10) << std::setprecision(10)
+                  << this->getValue<float>(k, l, i, j) << " ";
+            }
+            out << std::endl;
+          }
+          out << std::endl;
+        }
+        out << "-------" << std::endl;
+      }
+      out.copyfmt(init);
     }
-    out.copyfmt(init);
   } else if (getDataType() == ml::train::TensorDim::DataType::FP16) {
     const __fp16 *data = getData<__fp16>();
     unsigned int len = size();
@@ -1756,20 +2014,123 @@ void Tensor::print(std::ostream &out) const {
 
     std::ios init(NULL);
     init.copyfmt(out);
-    for (unsigned int k = 0; k < dim.batch(); k++) {
-      for (unsigned int l = 0; l < dim.channel(); l++) {
-        for (unsigned int i = 0; i < dim.height(); i++) {
-          for (unsigned int j = 0; j < dim.width(); j++) {
-            out << std::setw(10) << std::setprecision(10)
-                << this->getValue<__fp16>(k, l, i, j) << " ";
+    if (getFormat() == Tformat::NCHW) {
+      for (unsigned int k = 0; k < batch(); k++) {
+        for (unsigned int l = 0; l < channel(); l++) {
+          for (unsigned int i = 0; i < height(); i++) {
+            for (unsigned int j = 0; j < width(); j++) {
+              out << std::setw(10) << std::setprecision(10)
+                  << this->getValue<__fp16>(k, l, i, j) << " ";
+            }
+            out << std::endl;
+          }
+          out << std::endl;
+        }
+        out << "-------" << std::endl;
+      }
+    } else {
+      for (unsigned int k = 0; k < batch(); k++) {
+        for (unsigned int i = 0; i < height(); i++) {
+          for (unsigned int j = 0; j < width(); j++) {
+            for (unsigned int l = 0; l < channel(); l++) {
+              out << std::setw(10) << std::setprecision(10)
+                  << this->getValue<__fp16>(k, l, i, j) << " ";
+            }
+            out << std::endl;
           }
           out << std::endl;
         }
+        out << "-------" << std::endl;
+      }
+      out.copyfmt(init);
+    }    
+  }
+}
+
+void Tensor::print_(std::ostream &out, uint opt) const {
+  printInstance(out, this);
+  const float *data = getData();
+
+  unsigned int len = size();
+
+  std::ios init(NULL);
+  init.copyfmt(out);
+  if (opt == 0) {
+    if (getFormat() == Tformat::NCHW) {
+      out << "{";
+      for (unsigned int k = 0; k < batch(); k++) {
+        out << "{";
+        for (unsigned int i = 0; i < channel(); i++) {
+          out << "{";
+          for (unsigned int j = 0; j < height(); j++) {
+            out << "{";
+            for (unsigned int l = 0; l < width(); l++) {
+              if (l < channel() - 1)
+                out << std::setw(10) << std::setprecision(10)
+                    << this->getValue<float>(k, l, i, j) << ", ";
+              else
+                out << std::setw(10) << std::setprecision(10)
+                    << this->getValue<float>(k, l, i, j);
+            }
+            if (j < height() - 1)
+              out << "},";
+            else
+              out << "}";
+            out << std::endl;
+          }
+          if (i < channel() - 1)
+            out << "},";
+          else
+            out << "}";
+          out << std::endl;
+        }
+        if (k < batch() - 1)
+          out << "},";
+        else
+          out << "}";
         out << std::endl;
       }
-      out << "-------" << std::endl;
+      out << "}";
+    } else {
+      out << "{";
+      for (unsigned int k = 0; k < batch(); k++) {
+        out << "{";
+        for (unsigned int i = 0; i < height(); i++) {
+          out << "{";
+          for (unsigned int j = 0; j < width(); j++) {
+            out << "{";
+            for (unsigned int l = 0; l < channel(); l++) {
+              if (l < channel() - 1)
+                out << std::setw(10) << std::setprecision(10)
+                    << this->getValue<float>(k, l, i, j) << ", ";
+              else
+                out << std::setw(10) << std::setprecision(10)
+                    << this->getValue<float>(k, l, i, j);
+            }
+            if (j < width() - 1)
+              out << "},";
+            else
+              out << "}";
+            out << std::endl;
+          }
+          if (i < height() - 1)
+            out << "},";
+          else
+            out << "}";
+          out << std::endl;
+        }
+        if (k < batch() - 1)
+          out << "},";
+        else
+          out << "}";
+        out << std::endl;
+      }
+      out << "}";
+    }
+  } else {
+    for (uint i = 0; i < len; ++i) {
+      out << getData()<float>[i] << ", ";
     }
-    out.copyfmt(init);
   }
 }
 

diff --git a/nntrainer/tensor/tensor.h b/nntrainer/tensor/tensor.h
index 0a4613f..c928523 100644 (file)
--- a/nntrainer/tensor/tensor.h
+++ b/nntrainer/tensor/tensor.h
@@ -169,9 +169,9 @@ public:
 
   /**
    * @brief     Constructor of Tensor
-   * @param[in] d1 Channel (NCHW) or Height (NHWC)
-   * @param[in] d2 Height (NCHW) or Width (NHWC)
-   * @param[in] d3 Width (NCHW) or Channel (NHWC)
+   * @param[in] d1 Channel
+   * @param[in] d2 Height
+   * @param[in] d3 Width
    */
   Tensor(size_t d1, size_t d2, size_t d3, ml::train::TensorDim::TensorType t_type) :
     Tensor(1, d1, d2, d3, t_type){};
@@ -181,35 +181,46 @@ public:
    * @param[in] d2 Height (NCHW) or Width (NHWC)
    * @param[in] d3 Width (NCHW) or Channel (NHWC)
    */
-  Tensor(size_t d2, size_t d3,ml::train::TensorDim::TensorType t_type) :
-    Tensor(1, 1, d2, d3, t_type){};
-
+  Tensor(size_t d2, size_t d3, ml::train::TensorDim::TensorType t_type) :
+    Tensor(1, (t_type.format == Tformat::NCHW) ? 1 : d3,
+           (t_type.format == Tformat::NCHW) ? d2 : 1,
+           (t_type.format == Tformat::NCHW) ? d3 : d2, t_type){};
   /**
    * @brief     Constructor of Tensor with just Width or Channel
    * @param[in] d3 Width (NCHW) or Channel (NHWC)
    */
   explicit Tensor(size_t d3, ml::train::TensorDim::TensorType t_type) :
-    Tensor(1, 1, 1, d3, t_type){};
+    Tensor(1, (t_type.format == Tformat::NCHW) ? 1 : d3, 1,
+           (t_type.format == Tformat::NCHW) ? d3 : 1, t_type){};
   
-
   /**
    * @brief     Constructor of Tensor
    * @param[in] d data for the Tensor. It needs to set format properly.
    */
-  Tensor(std::vector<std::vector<std::vector<std::vector<float>>>> const &d) {
+
+  Tensor(std::vector<std::vector<std::vector<std::vector<float>>>> const &d,
+         Tformat fm) {
 
     if (d.empty() || d[0].empty() || d[0][0].empty() || d[0][0][0].empty()) {
       throw std::out_of_range(
         "[Tensor] trying to initialize Tensor from empty vector");
     }
+    // if fm == Tformat::NCHW, then dim[0] == batch , dim[1] == channel, dim[2]
+    // == height, dim[3] == width. and if fm == Tformat::NHWC, dim[0] == batch,
+    // dim[1] == height, dim[2] == width, dim[3] == channel
+    dim.setTensorDim(0, d.size());
+    if (fm == Tformat::NCHW) {
+      dim.setTensorDim(1, d[0].size());
+      dim.setTensorDim(2, d[0][0].size());
+      dim.setTensorDim(3, d[0][0][0].size());
+    } else {
+      dim.setTensorDim(2, d[0].size());
+      dim.setTensorDim(3, d[0][0].size());
+      dim.setTensorDim(1, d[0][0][0].size());
+    }
 
-    dim.batch(d.size());
-    dim.channel(d[0].size());
-    dim.height(d[0][0].size());
-    dim.width(d[0][0][0].size());
-    strides = dim.computeStrides();
-
-    MemoryData* mem_data = new MemoryData((void *)(new float[dim.getDataLen()]()));
+    MemoryData *mem_data =
+      new MemoryData((void *)(new float[dim.getDataLen()]()));
     data = std::shared_ptr<MemoryData>(mem_data, [](MemoryData *mem_data) {
       delete[] mem_data->getAddr<float>();
     });
@@ -219,12 +230,22 @@ public:
 
     setDataType(Tdatatype::FP32);
 
-    for (unsigned int i = 0; i < dim.batch(); ++i)
-      for (unsigned int j = 0; j < dim.channel(); ++j)
-        for (unsigned int k = 0; k < dim.height(); ++k)
-          for (unsigned int l = 0; l < dim.width(); ++l) {
-            this->setValue(i, j, k, l, d[i][j][k][l]);
-          }
+    // if fm == Tformat::NCHW, then dim[0] == batch , dim[1] == channel, dim[2]
+    // == height, dim[3] == width. and if fm == Tformat::NHWC, dim[0] == batch,
+    // dim[1] == height, dim[2] == width, dim[3] == channel
+    if (fm == Tformat::NCHW) {
+      for (unsigned int i = 0; i < batch(); ++i)
+        for (unsigned int j = 0; j < channel(); ++j)
+          for (unsigned int k = 0; k < height(); ++k)
+            for (unsigned int l = 0; l < width(); ++l)
+              this->setValue(i, j, k, l, d[i][j][k][l]);
+    } else {
+      for (unsigned int i = 0; i < batch(); ++i)
+        for (unsigned int j = 0; j < height(); ++j)
+          for (unsigned int k = 0; k < width(); ++k)
+            for (unsigned int l = 0; l < channel(); ++l)
+              this->setValue(i, l, j, k, d[i][j][k][l]);
+    }
   };
 
   /**
@@ -244,20 +265,27 @@ public:
   Tensor(std::vector<std::vector<float>> const &d, Tformat fm = Tformat::NCHW) :
     Tensor(std::vector<std::decay<decltype(d)>::type>{d}, fm){};
 
-  Tensor(std::vector<std::vector<std::vector<std::vector<__fp16>>>> const &d) {
+  Tensor(std::vector<std::vector<std::vector<std::vector<__fp16>>>> const &d,
+         Tformat fm) {
 
     if (d.empty() || d[0].empty() || d[0][0].empty() || d[0][0][0].empty()) {
       throw std::out_of_range(
         "[Tensor] trying to initialize Tensor from empty vector");
     }
 
-    dim.batch(d.size());
-    dim.channel(d[0].size());
-    dim.height(d[0][0].size());
-    dim.width(d[0][0][0].size());
-    strides = dim.computeStrides();
+    dim.setTensorDim(0, d.size());
+    if (fm == Tformat::NCHW) {
+      dim.setTensorDim(1, d[0].size());
+      dim.setTensorDim(2, d[0][0].size());
+      dim.setTensorDim(3, d[0][0][0].size());
+    } else {
+      dim.setTensorDim(2, d[0].size());
+      dim.setTensorDim(3, d[0][0].size());
+      dim.setTensorDim(1, d[0][0][0].size());
+    }
 
-    MemoryData* mem_data = new MemoryData((void *)(new __fp16[dim.getDataLen()]()));
+    MemoryData *mem_data =
+      new MemoryData((void *)(new __fp16[dim.getDataLen()]()));
     data = std::shared_ptr<MemoryData>(mem_data, [](MemoryData *mem_data) {
       delete[] mem_data->getAddr<__fp16>();
     });
@@ -267,11 +295,22 @@ public:
 
     setDataType(Tdatatype::FP16);
 
-    for (unsigned int i = 0; i < dim.batch(); ++i)
-      for (unsigned int j = 0; j < dim.channel(); ++j)
-        for (unsigned int k = 0; k < dim.height(); ++k)
-          for (unsigned int l = 0; l < dim.width(); ++l)
-            this->setValue(i, j, k, l, d[i][j][k][l]);
+    // if fm == Tformat::NCHW, then dim[0] == batch , dim[1] == channel, dim[2]
+    // == height, dim[3] == width. and if fm == Tformat::NHWC, dim[0] == batch,
+    // dim[1] == height, dim[2] == width, dim[3] == channel
+    if (fm == Tformat::NCHW) {
+      for (unsigned int i = 0; i < batch(); ++i)
+        for (unsigned int j = 0; j < channel(); ++j)
+          for (unsigned int k = 0; k < height(); ++k)
+            for (unsigned int l = 0; l < width(); ++l)
+              this->setValue(i, j, k, l, d[i][j][k][l]);
+    } else {
+      for (unsigned int i = 0; i < batch(); ++i)
+        for (unsigned int j = 0; j < height(); ++j)
+          for (unsigned int k = 0; k < width(); ++k)
+            for (unsigned int l = 0; l < channel(); ++l)
+              this->setValue(i, l, j, k, d[i][j][k][l]);
+    }
   };
 
   /**
@@ -279,16 +318,18 @@ public:
    * @note      This constructor copies vector again. needs refactoring
    * @param[in] d data for the Tensor
    */
-  Tensor(std::vector<std::vector<std::vector<__fp16>>> const &d) :
-    Tensor(std::vector<std::decay<decltype(d)>::type>{d}){};
+  Tensor(std::vector<std::vector<std::vector<__fp16>>> const &d,
+         Tformat fm = Tformat::NCHW) :
+    Tensor(std::vector<std::decay<decltype(d)>::type>{d}, fm){};
 
   /**
    * @brief     Constructor of Tensor
    * @note      This constructor copies vector again. needs refactoring
    * @param[in] d data for the Tensor with batch size one
    */
-  Tensor(std::vector<std::vector<__fp16>> const &d) :
-    Tensor(std::vector<std::decay<decltype(d)>::type>{d}){};
+  Tensor(std::vector<std::vector<__fp16>> const &d,
+         Tformat fm = Tformat::NCHW) :
+    Tensor(std::vector<std::decay<decltype(d)>::type>{d}, fm){};
 
   /**
    *  @brief  Copy constructor of Tensor.

diff --git a/nntrainer/tensor/tensor_dim.cpp b/nntrainer/tensor/tensor_dim.cpp
index eb954e3..00893f9 100644 (file)
--- a/nntrainer/tensor/tensor_dim.cpp
+++ b/nntrainer/tensor/tensor_dim.cpp
@@ -60,17 +60,9 @@ TensorDim::TensorDim(std::initializer_list<size_t> dims, TensorType t_type_) :
   }
 }
 
-// TensorDim::TensorDim(std::initializer_list<size_t> dims, TensorDim::Format fm,
-//                      TensorDim::DataType d_type) :
-//   TensorDim(dims, TensorType{fm, d_type}) {}
-
 TensorDim::TensorDim(const std::array<size_t, 3> &shapes, TensorType t_type_) :
   TensorDim({shapes[0], shapes[1], shapes[2]}, t_type_) {}
 
-// TensorDim::TensorDim(const std::array<size_t, 3> &shapes, TensorDim::Format fm,
-//                      TensorDim::DataType d_type) :
-  // TensorDim({shapes[0], shapes[1], shapes[2]}, TensorType{fm, d_type}) {}
-
 TensorDim::TensorDim(size_t d0, size_t d1, size_t d2, size_t d3,
                      TensorType t_type_,
                      const std::bitset<MAXDIM> &eff_dim_flag_,
@@ -218,17 +210,11 @@ void swap(TensorDim &lhs, TensorDim &rhs) noexcept {
 
 size_t TensorDim::batch() const { return dim[0]; };
 
-size_t TensorDim::channel() const {
-  return t_type.format == Format::NCHW ? dim[1] : dim[3];
-};
+size_t TensorDim::channel() const { return dim[1]; };
 
-size_t TensorDim::height() const {
-  return t_type.format == Format::NCHW ? dim[2] : dim[1];
-};
+size_t TensorDim::height() const { return dim[2]; };
 
-size_t TensorDim::width() const {
-  return t_type.format == Format::NCHW ? dim[3] : dim[2];
-};
+size_t TensorDim::width() const { return dim[3]; };
 
 size_t TensorDim::getDataLen() const { return len; };
 
@@ -236,20 +222,11 @@ size_t TensorDim::getFeatureLen() const { return feature_len; };
 
 void TensorDim::batch(size_t b) { setTensorDim(0, b); }
 
-void TensorDim::channel(size_t c) {
-  uint i = (t_type.format == Format::NCHW) ? 1 : 3;
-  setTensorDim(i, c);
-}
+void TensorDim::channel(size_t c) { setTensorDim(1, c); }
 
-void TensorDim::height(size_t h) {
-  uint i = (t_type.format == Format::NCHW) ? 2 : 1;
-  setTensorDim(i, h);
-}
+void TensorDim::height(size_t h) { setTensorDim(2, h); }
 
-void TensorDim::width(size_t w) {
-  uint i = (t_type.format == Format::NCHW) ? 3 : 2;
-  setTensorDim(i, w);
-}
+void TensorDim::width(size_t w) { setTensorDim(3, w); }
 
 const size_t *TensorDim::getDim() const { return dim; }
 
@@ -358,6 +335,7 @@ std::vector<int> TensorDim::getEffectiveDimension(bool dynamic) const {
 bool TensorDim::is_dynamic() const { return dyn_dim_flag.any(); }
 
 std::ostream &operator<<(std::ostream &out, TensorDim const &d) {
+
   std::string type_ =
     (d.getDataType() == ml::train::TensorDim::DataType::FP16) ? "FP16" : "FP32";
   std::string format_ =

diff --git a/test/unittest/meson.build b/test/unittest/meson.build
index 9efde0f..0846cc1 100644 (file)
--- a/test/unittest/meson.build
+++ b/test/unittest/meson.build
@@ -38,6 +38,7 @@ test_target = [
   ['unittest_nntrainer_lazy_tensor', []],
   ['unittest_nntrainer_tensor', []],
   ['unittest_nntrainer_tensor_fp16', []],
+  ['unittest_nntrainer_tensor_nhwc', []],
   ['unittest_util_func', []],
   ['unittest_nntrainer_modelfile', []],
   ['unittest_nntrainer_models', [

diff --git a/test/unittest/unittest_nntrainer_tensor.cpp b/test/unittest/unittest_nntrainer_tensor.cpp
index 4e2b173..456b599 100644 (file)
--- a/test/unittest/unittest_nntrainer_tensor.cpp
+++ b/test/unittest/unittest_nntrainer_tensor.cpp
@@ -65,44 +65,10 @@ TEST(nntrianer_TensorDim, effective_dimension_p) {
   EXPECT_EQ(moved_t.getEffectiveDimension(true), std::vector<int>({-1, -1}));
 }
 
-TEST(nntrianer_TensorDim, effective_dimension_nhwc_p) {
-  nntrainer::TensorDim t(3, 2, 4, 5, nntrainer::Tformat::NHWC, nntrainer::Tdatatype::FP32);
-  EXPECT_EQ(t.getEffectiveDimension(), std::vector<int>({3, 2, 4, 5}));
-
-  t.setEffDimFlag(0b1101);
-  EXPECT_EQ(t.getEffectiveDimension(), std::vector<int>({3, 2, 5}));
-
-  t.setEffDimFlag(0b0011);
-  EXPECT_EQ(t.getEffectiveDimension(), std::vector<int>({4, 5}));
-
-  t.setEffDimFlag(0b1111);
-  EXPECT_EQ(t.getEffectiveDimension(), std::vector<int>({3, 2, 4, 5}));
-
-  t.setEffDimFlag(0b1100);
-  EXPECT_EQ(t.getEffectiveDimension(), std::vector<int>({3, 2}));
-
-  t.setDynDimFlag(0b1100);
-  EXPECT_EQ(t.getEffectiveDimension(true), std::vector<int>({-1, -1}));
-
-  auto copied_t = t;
-  EXPECT_EQ(copied_t.getEffectiveDimension(), std::vector<int>({3, 2}));
-  EXPECT_EQ(copied_t.getEffectiveDimension(true), std::vector<int>({-1, -1}));
-
-  auto moved_t = std::move(copied_t);
-  EXPECT_EQ(moved_t.getEffectiveDimension(), std::vector<int>({3, 2}));
-  EXPECT_EQ(moved_t.getEffectiveDimension(true), std::vector<int>({-1, -1}));
-}
-
 TEST(nntrainer_TensorDim, ctor_initializer_n) {
   EXPECT_THROW(nntrainer::TensorDim t({1, 2, 3, 4, 5}), std::invalid_argument);
 }
 
-TEST(nntrainer_TensorDim, ctor_initializer_nhwc_n) {
-  EXPECT_THROW(
-    nntrainer::TensorDim t({1, 2, 3, 4, 5}, nntrainer::Tformat::NHWC, nntrainer::Tdatatype::FP32),
-    std::invalid_argument);
-}
-
 TEST(nntrainer_TensorDim, setTensorDim_01_p) {
   int status = ML_ERROR_NONE;
 
@@ -111,14 +77,6 @@ TEST(nntrainer_TensorDim, setTensorDim_01_p) {
   EXPECT_EQ(status, ML_ERROR_NONE);
 }
 
-TEST(nntrainer_TensorDim, setTensorDim_01_nhwc_p) {
-  int status = ML_ERROR_NONE;
-
-  nntrainer::TensorDim tensor_dim;
-  status = tensor_dim.setTensorDim("1:2:3:4", {nntrainer::Tformat::NHWC, nntrainer::Tdatatype::FP32});
-  EXPECT_EQ(status, ML_ERROR_NONE);
-}
-
 TEST(nntrainer_TensorDim, setTensorDim_02_n) {
   int status = ML_ERROR_NONE;
 
@@ -127,14 +85,6 @@ TEST(nntrainer_TensorDim, setTensorDim_02_n) {
   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 }
 
-TEST(nntrainer_TensorDim, setTensorDim_02__nhwc_n) {
-  int status = ML_ERROR_NONE;
-
-  nntrainer::TensorDim tensor_dim;
-  status = tensor_dim.setTensorDim("1:2:3:4:5", {nntrainer::Tformat::NHWC, nntrainer::Tdatatype::FP32});
-  EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
-}
-
 TEST(nntrainer_TensorDim, setTensorDim_03_n) {
   nntrainer::TensorDim d;
 
@@ -144,15 +94,6 @@ TEST(nntrainer_TensorDim, setTensorDim_03_n) {
   EXPECT_THROW(d.setTensorDim(3, 0), std::invalid_argument);
 }
 
-TEST(nntrainer_TensorDim, setTensorDim_03_nhwc_n) {
-  nntrainer::TensorDim d(nntrainer::Tformat::NHWC, nntrainer::Tdatatype::FP32);
-
-  EXPECT_THROW(d.setTensorDim(0, 0), std::invalid_argument);
-  EXPECT_THROW(d.setTensorDim(1, 0), std::invalid_argument);
-  EXPECT_THROW(d.setTensorDim(2, 0), std::invalid_argument);
-  EXPECT_THROW(d.setTensorDim(3, 0), std::invalid_argument);
-}
-
 TEST(nntrainer_TensorDim, setTensorDim_04_p) {
   nntrainer::TensorDim d;
 
@@ -167,19 +108,6 @@ TEST(nntrainer_TensorDim, setTensorDim_04_p) {
   EXPECT_EQ(d.width(), 7u);
 }
 
-TEST(nntrainer_TensorDim, setTensorDim_04_nhwc_p) {
-  nntrainer::TensorDim d(nntrainer::Tformat::NHWC, nntrainer::Tdatatype::FP32);
-
-  d.setTensorDim(0, 4);
-  d.setTensorDim(1, 5);
-  d.setTensorDim(2, 6);
-  d.setTensorDim(3, 7);
-
-  EXPECT_EQ(d.batch(), 4u);
-  EXPECT_EQ(d.height(), 5u);
-  EXPECT_EQ(d.width(), 6u);
-  EXPECT_EQ(d.channel(), 7u);
-}
 
 TEST(nntrainer_Tensor, Tensor_01_p) {
   int status = ML_ERROR_NONE;
@@ -191,32 +119,27 @@ TEST(nntrainer_Tensor, Tensor_01_p) {
   EXPECT_EQ(status, ML_ERROR_NONE);
 }
 
-TEST(nntrainer_Tensor, Tensor_01_nhwc_p) {
-  int status = ML_ERROR_NONE;
-  nntrainer::Tensor tensor =
-    nntrainer::Tensor(1, 2, 3, nntrainer::Tformat::NHWC, nntrainer::Tdatatype::FP32);
-  tensor.setZero();
-  ASSERT_NE(nullptr, tensor.getData());
-  if (tensor.getValue(0, 0, 0, 0) != 0.0)
-    status = ML_ERROR_INVALID_PARAMETER;
-  EXPECT_EQ(status, ML_ERROR_NONE);
-}
 
-TEST(nntrainer_Tensor, Tensor_02_p) {
-  int status = ML_ERROR_NONE;
-  int height = 3;
-  int width = 10;
-  std::vector<std::vector<float>> in;
-  for (int i = 0; i < height; ++i) {
-    std::vector<float> tv;
-    for (int j = 0; j < width; ++j) {
-      tv.push_back(i * 2.0 + j);
-    }
-    in.push_back(tv);
-  }
+// TEST(nntrainer_Tensor, Tensor_02_p) {
+//   int status = ML_ERROR_NONE;
+//   int height = 3;
+//   int width = 10;
+//   std::vector<std::vector<float>> in;
+//   for (int i = 0; i < height; ++i) {
+//     std::vector<float> tv;
+//     for (int j = 0; j < width; ++j) {
+//       tv.push_back(i * 2.0 + j);
+//     }
+//     in.push_back(tv);
+//   }
 
-  nntrainer::Tensor tensor = nntrainer::Tensor(in);
-  ASSERT_NE(nullptr, tensor.getData());
+//   nntrainer::Tensor tensor = nntrainer::Tensor(in);
+//   ASSERT_NE(nullptr, tensor.getData());
+
+//   if (tensor.getValue(0, 0, 0, 1) != 1.0)
+//     status = ML_ERROR_INVALID_PARAMETER;
+//   EXPECT_EQ(status, ML_ERROR_NONE);
+// }
 
 // TEST(nntrainer_Tensor, Tensor_02_nhwc_p) {
 //   int status = ML_ERROR_NONE;
@@ -237,7 +160,6 @@ TEST(nntrainer_Tensor, Tensor_02_p) {
 //   if (tensor.getValue(0, 0, 0, 1) != 1.0)
 //     status = ML_ERROR_INVALID_PARAMETER;
 //   EXPECT_EQ(status, ML_ERROR_NONE);
-}
 
 TEST(nntrainer_Tensor, Tensor_03_p) {
   int status = ML_ERROR_NONE;

diff --git a/test/unittest/unittest_nntrainer_tensor_nhwc.cpp b/test/unittest/unittest_nntrainer_tensor_nhwc.cpp
index 8584574..6450434 100644 (file)
--- a/test/unittest/unittest_nntrainer_tensor_nhwc.cpp
+++ b/test/unittest/unittest_nntrainer_tensor_nhwc.cpp
@@ -19,6 +19,7 @@
 #include <tensor_dim.h>
 
 #define NHWC_ nntrainer::Tformat::NHWC
+#define FP32_ nntrainer::Tdatatype::FP32
 
 TEST(nntrainer_TensorDim, ctor_initializer_nhwc_p) {
   unsigned int b = 3;
@@ -40,7 +41,7 @@ TEST(nntrainer_TensorDim, ctor_initializer_nhwc_p) {
 }
 
 TEST(nntrianer_TensorDim, effective_dimension_nhwc_p) {
-  nntrainer::TensorDim t(3, 2, 4, 5, NHWC_);
+  nntrainer::TensorDim t(3, 2, 4, 5, NHWC_, FP32_);
   EXPECT_EQ(t.getEffectiveDimension(), std::vector<int>({3, 2, 4, 5}));
 
   t.setEffDimFlag(0b1101);
@@ -68,7 +69,11 @@ TEST(nntrianer_TensorDim, effective_dimension_nhwc_p) {
 }
 
 TEST(nntrainer_TensorDim, ctor_initializer_nhwc_n) {
+<<<<<<< HEAD
   EXPECT_THROW(nntrainer::TensorDim t({1, 2, 3, 4, 5}, NHWC_),
+=======
+  EXPECT_THROW(nntrainer::TensorDim t({1, 2, 3, 4, 5}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                std::invalid_argument);
 }
 
@@ -76,7 +81,11 @@ TEST(nntrainer_TensorDim, setTensorDim_01_nhwc_p) {
   int status = ML_ERROR_NONE;
 
   nntrainer::TensorDim tensor_dim;
+<<<<<<< HEAD
   status = tensor_dim.setTensorDim("1:2:3:4", NHWC_);
+=======
+  status = tensor_dim.setTensorDim("1:2:3:4", NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(status, ML_ERROR_NONE);
 }
 
@@ -84,12 +93,20 @@ TEST(nntrainer_TensorDim, setTensorDim_02__nhwc_n) {
   int status = ML_ERROR_NONE;
 
   nntrainer::TensorDim tensor_dim;
+<<<<<<< HEAD
   status = tensor_dim.setTensorDim("1:2:3:4:5", NHWC_);
+=======
+  status = tensor_dim.setTensorDim("1:2:3:4:5", NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 }
 
 TEST(nntrainer_TensorDim, setTensorDim_03_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::TensorDim d(NHWC_);
+=======
+  nntrainer::TensorDim d(NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_THROW(d.setTensorDim(0, 0), std::invalid_argument);
   EXPECT_THROW(d.setTensorDim(1, 0), std::invalid_argument);
@@ -98,7 +115,11 @@ TEST(nntrainer_TensorDim, setTensorDim_03_nhwc_n) {
 }
 
 TEST(nntrainer_TensorDim, setTensorDim_04_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::TensorDim d(NHWC_);
+=======
+  nntrainer::TensorDim d(NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   d.setTensorDim(0, 4);
   d.setTensorDim(1, 5);
@@ -113,7 +134,11 @@ TEST(nntrainer_TensorDim, setTensorDim_04_nhwc_p) {
 
 TEST(nntrainer_Tensor, Tensor_01_nhwc_p) {
   int status = ML_ERROR_NONE;
+<<<<<<< HEAD
   nntrainer::Tensor tensor = nntrainer::Tensor(1, 2, 3, NHWC_);
+=======
+  nntrainer::Tensor tensor = nntrainer::Tensor(1, 2, 3, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   tensor.setZero();
   ASSERT_NE(nullptr, tensor.getData());
   if (tensor.getValue(0, 0, 0, 0) != 0.0)
@@ -139,7 +164,11 @@ TEST(nntrainer_Tensor, Tensor_03_nhwc_p) {
     in.push_back(ttv);
   }
 
+<<<<<<< HEAD
   nntrainer::Tensor tensor = nntrainer::Tensor(in, NHWC_);
+=======
+  nntrainer::Tensor tensor = nntrainer::Tensor(in, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   ASSERT_NE(nullptr, tensor.getData());
 
   if (tensor.getValue(0, 1, 0, 0) != 1.0)
@@ -154,7 +183,11 @@ TEST(nntrainer_Tensor, multiply_i_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l);
 
@@ -181,7 +214,11 @@ TEST(nntrainer_Tensor, multiply_i_02_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (channel * height * width) +
                                j * (width * channel) + k * channel + l);
 
@@ -208,11 +245,19 @@ TEST(nntrainer_Tensor, multiply_i_03_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT(input, i * (channel * height * width) + j * (width * channel) +
                           k * channel + l);
 
   nntrainer::Tensor target2(batch, channel, height - 2, width - 1, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT(input, i * (channel * height * width) + j * (width * channel) +
+                          k * channel + l);
+
+  nntrainer::Tensor target2(batch, channel, height - 2, width - 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   status = input.multiply_i(target2);
 
   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
@@ -225,9 +270,15 @@ TEST(nntrainer_Tensor, multiply_i_03_nhwc_n) {
 
 TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor m = ranged(1, 2, 4, 5, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 2, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     float answer_data[] = {
       0,    1,    4,    9,    16,   25,   36,   49,   64,   81,   100,  121,
@@ -246,9 +297,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 5, 2, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 5, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,    0,    0,    0,    4,    5,    6,    7,    16,   18,   20,   22,
       36,   39,   42,   45,   64,   68,   72,   76,   100,  105,  110,  115,
@@ -266,9 +323,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 4, 5, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 4, 5, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,    1,    4,    9,    0,    5,    12,   21,   32,   45,   60,   77,
       48,   65,   84,   105,  128,  153,  180,  209,  160,  189,  220,  253,
@@ -287,9 +350,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 1, 2, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 1, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   0,   0,   0,   4,   5,   6,   7,   0,   0,   0,   0,   12,  13,
       14,  15,  0,   0,   0,   0,   20,  21,  22,  23,  0,   0,   0,   0,
@@ -306,9 +375,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(1, 4, 1, 2, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 4, 1, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   4,   9,   16,  25,  36,  49,  0,   9,   20,  33,  48,  65,
       84,  105, 0,   17,  36,  57,  80,  105, 132, 161, 0,   25,  52,  81,
@@ -325,9 +400,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 5, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 5, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,    0,    0,    0,    0,    0,    0,    0,    8,    9,    10,   11,
       12,   13,   14,   15,   32,   34,   36,   38,   40,   42,   44,   46,
@@ -346,9 +427,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(1, 1, 1, 2, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 1, 1, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  0,  0,  0,   4,   5,   6,   7,  0,  0,  0,   0,   12,  13,  14,
       15, 0,  0,  0,   0,   20,  21,  22, 23, 0,  0,   0,   0,   28,  29,
@@ -365,9 +452,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(1, 4, 1, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 4, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0, 1,   4,   9,   0, 5,   12,  21,  0, 9,   20,  33,  0, 13,  28,  45,
       0, 17,  36,  57,  0, 21,  44,  69,  0, 25,  52,  81,  0, 29,  60,  93,
@@ -383,9 +476,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 1, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
       0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
@@ -402,9 +501,15 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 1, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 1, 4, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 1, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 1, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 1, 4, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 1, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {0,   0,   0,   0,   0,   5,   6,   7,   8,   9,
                            20,  22,  24,  26,  28,  45,  48,  51,  54,  57,
                            80,  84,  88,  92,  96,  125, 130, 135, 140, 145,
@@ -419,15 +524,25 @@ TEST(nntrainer_Tensor, multiply_i_broadcast_01_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, multiply_i_broadcast_not_supported_01_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 1, 3, 1, NHWC_);
   nntrainer::Tensor target2(3, 1, 3, 3, NHWC_);
+=======
+  nntrainer::Tensor target(3, 1, 3, 1, NHWC_, FP32_);
+  nntrainer::Tensor target2(3, 1, 3, 3, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_EQ(target.multiply_i(target2), ML_ERROR_INVALID_PARAMETER);
 }
 
 TEST(nntrainer_Tensor, multiply_i_broadcast_not_broadcastable_02_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 2, 4, 5, NHWC_);
   nntrainer::Tensor target2(3, 2, 3, 1, NHWC_);
+=======
+  nntrainer::Tensor target(3, 2, 4, 5, NHWC_, FP32_);
+  nntrainer::Tensor target2(3, 2, 3, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_EQ(target.multiply_i(target2), ML_ERROR_INVALID_PARAMETER);
 }
@@ -439,7 +554,11 @@ TEST(nntrainer_Tensor, multiply_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l);
 
@@ -456,7 +575,11 @@ TEST(nntrainer_Tensor, multiply_02_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT(input,
                  i * (batch * height * width) + j * (height * width) + k + 1);
 
@@ -483,11 +606,19 @@ TEST(nntrainer_Tensor, multiply_03_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT(input,
                  i * (height * width) + j * (height * width) + k * width + l);
 
   nntrainer::Tensor test(batch - 1, height - 1, width - 1, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT(input,
+                 i * (height * width) + j * (height * width) + k * width + l);
+
+  nntrainer::Tensor test(batch - 1, height - 1, width - 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_THROW({ input.multiply(test); }, std::invalid_argument);
 }
@@ -498,9 +629,15 @@ TEST(nntrainer_Tensor, multiply_04_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
 
   nntrainer::Tensor input(batch, 2 * channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+
+  nntrainer::Tensor input(batch, 2 * channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor shared_input = input.getSharedDataTensor(dim, 0, false);
   nntrainer::Tensor test(dim);
   // shared_input is not continuous
@@ -513,10 +650,17 @@ TEST(nntrainer_Tensor, multiply_05_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
 
   nntrainer::Tensor input(dim);
   nntrainer::Tensor test(batch, 2 * channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+
+  nntrainer::Tensor input(dim);
+  nntrainer::Tensor test(batch, 2 * channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor shared_test = test.getSharedDataTensor(dim, 0, false);
 
   EXPECT_THROW(input.multiply(shared_test), std::invalid_argument);
@@ -528,7 +672,11 @@ TEST(nntrainer_Tensor, multiply_06_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   // input is not allocated now : alloc_now == false
   nntrainer::Tensor input(dim, false);
   nntrainer::Tensor test(dim);
@@ -544,7 +692,11 @@ TEST(nntrainer_Tensor, multiply_07_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT(input, i * (height * width * channel) + j * (width * channel) +
@@ -561,7 +713,11 @@ TEST(nntrainer_Tensor, multiply_08_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT(input, i * (height * width * channel) + j * (width * channel) +
@@ -581,11 +737,19 @@ TEST(nntrainer_Tensor, multiply_float_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
 
   nntrainer::Tensor expected(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
+                               j * (width * channel) + k * channel + 1);
+
+  nntrainer::Tensor expected(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(expected, (i * (height * width * channel) +
                                  j * (width * channel) + k * channel + 1) *
                                   2);
@@ -602,7 +766,11 @@ TEST(nntrainer_Tensor, divide_i_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l);
 
@@ -629,7 +797,11 @@ TEST(nntrainer_Tensor, divide_i_02_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l + 1);
 
@@ -650,7 +822,11 @@ TEST(nntrainer_Tensor, divide_i_01_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l + 1);
 
@@ -665,11 +841,19 @@ TEST(nntrainer_Tensor, divide_i_02_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l + 1);
 
   nntrainer::Tensor original(batch, channel, height - 2, width - 1, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
+                               j * (width * channel) + k * channel + l + 1);
+
+  nntrainer::Tensor original(batch, channel, height - 2, width - 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   status = input.divide_i(original);
   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
@@ -681,7 +865,11 @@ TEST(nntrainer_Tensor, divide_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l + 1);
 
@@ -703,7 +891,11 @@ TEST(nntrainer_Tensor, divide_02_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l + 1);
 
@@ -716,11 +908,19 @@ TEST(nntrainer_Tensor, divide_03_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l + 1);
 
   nntrainer::Tensor test(batch - 1, channel - 1, height - 1, width - 1, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
+                               j * (width * channel) + k * channel + l + 1);
+
+  nntrainer::Tensor test(batch - 1, channel - 1, height - 1, width - 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_THROW({ input.divide(test); }, std::invalid_argument);
 }
@@ -731,9 +931,15 @@ TEST(nntrainer_Tensor, divide_04_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
 
   nntrainer::Tensor input(batch, 2 * channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+
+  nntrainer::Tensor input(batch, 2 * channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor shared_input = input.getSharedDataTensor(dim, 0, false);
   nntrainer::Tensor test(dim);
 
@@ -746,10 +952,17 @@ TEST(nntrainer_Tensor, divide_05_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
 
   nntrainer::Tensor input(dim);
   nntrainer::Tensor test(batch, 2 * channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+
+  nntrainer::Tensor input(dim);
+  nntrainer::Tensor test(batch, 2 * channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor shared_test = test.getSharedDataTensor(dim, 0, false);
 
   EXPECT_THROW(input.divide(shared_test), std::invalid_argument);
@@ -761,7 +974,11 @@ TEST(nntrainer_Tensor, divide_06_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim, false);
   nntrainer::Tensor test(dim);
@@ -778,7 +995,11 @@ TEST(nntrainer_Tensor, divide_07_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
@@ -794,7 +1015,11 @@ TEST(nntrainer_Tensor, divide_08_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
@@ -809,10 +1034,17 @@ TEST(nntrainer_Tensor, divide_08_nhwc_n) {
 
 TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(1, 2, 4, 5, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(1, 2, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
       1.0,       1.0,       1.0,       1.0,       1.0,       1.0,
@@ -841,10 +1073,17 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(3, 1, 4, 5, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(3, 1, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
 
@@ -864,10 +1103,17 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(3, 2, 1, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(3, 2, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
       1,         1,         3,         2,         5,         3,
@@ -896,10 +1142,17 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(1, 2, 4, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(1, 2, 4, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
       1,         1,         3,         2,         5,         3,
@@ -928,10 +1181,17 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(3, 1, 1, 5, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(3, 1, 1, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
       1,         2,         1.5,       2,         1.6666666, 2,
@@ -960,10 +1220,17 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(1, 2, 1, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(1, 2, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
 
@@ -981,10 +1248,17 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(1, 1, 4, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(1, 1, 4, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
       1,         2,         3,     4,         5,         6,
@@ -1013,10 +1287,17 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(3, 1, 1, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 4, 5, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(3, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
 
@@ -1046,10 +1327,17 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 2, 5, 1, NHWC_);
     nntrainer::Tensor t = ranged(3, 2, 5, 1, NHWC_);
     t.add_i(1);
     nntrainer::Tensor m = ranged(3, 2, 1, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 2, 5, 1, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 2, 5, 1, NHWC_, FP32_);
+    t.add_i(1);
+    nntrainer::Tensor m = ranged(3, 2, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1);
     float answer_data[] = {
       1,       1,       3,       2,   5, 3,       7,       4,       9,       5,
@@ -1064,15 +1352,25 @@ TEST(nntrainer_Tensor, divide_i_broadcast_01_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, divide_i_broadcast_not_supported_01_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 1, 3, 1, NHWC_);
   nntrainer::Tensor target2(3, 1, 3, 3, NHWC_);
+=======
+  nntrainer::Tensor target(3, 1, 3, 1, NHWC_, FP32_);
+  nntrainer::Tensor target2(3, 1, 3, 3, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_EQ(target.divide_i(target2), ML_ERROR_INVALID_PARAMETER);
 }
 
 TEST(nntrainer_Tensor, divide_i_broadcast_not_broadcastable_02_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 2, 4, 5, NHWC_);
   nntrainer::Tensor target2(3, 2, 3, 1, NHWC_);
+=======
+  nntrainer::Tensor target(3, 2, 4, 5, NHWC_, FP32_);
+  nntrainer::Tensor target2(3, 2, 3, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_EQ(target.divide_i(target2), ML_ERROR_INVALID_PARAMETER);
 }
@@ -1087,10 +1385,17 @@ TEST(nntrainer_Tensor, add_i_01_nhwc_n) {
   int width = 10;
   int channel = 1;
 
+<<<<<<< HEAD
   nntrainer::Tensor target(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT(target, i * (batch * height) + j * (width) + k + 1);
 
   nntrainer::Tensor target2(batch, height - 2, width - 3, NHWC_);
+=======
+  nntrainer::Tensor target(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT(target, i * (batch * height) + j * (width) + k + 1);
+
+  nntrainer::Tensor target2(batch, height - 2, width - 3, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   status = target.add_i(target2);
   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
@@ -1103,7 +1408,11 @@ TEST(nntrainer_Tensor, add_i_01_nhwc_p) {
   int width = 10;
   int channel = 3;
 
+<<<<<<< HEAD
   nntrainer::Tensor target(batch, height, width, channel, NHWC_);
+=======
+  nntrainer::Tensor target(batch, height, width, channel, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
                                 j * (width * channel) + k * channel + 1 + l);
 
@@ -1130,11 +1439,19 @@ TEST(nntrainer_Tensor, add_i_02_nhwc_p) {
   int width = 10;
   int channel = 2;
 
+<<<<<<< HEAD
   nntrainer::Tensor target(batch, height, width, channel, NHWC_);
   GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
                                 j * (width * channel) + k * channel + 1);
 
   nntrainer::Tensor original(height, width, channel, NHWC_);
+=======
+  nntrainer::Tensor target(batch, height, width, channel, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
+                                j * (width * channel) + k * channel + 1);
+
+  nntrainer::Tensor original(height, width, channel, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   original.copy(target);
 
   status = target.add_i(target, 3.0);
@@ -1151,10 +1468,17 @@ TEST(nntrainer_Tensor, add_i_02_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_);
   {
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(1, 4, 5, 2, NHWC_);
+=======
+  nntrainer::TensorDim ref_dim(3, 4, 5, 2, NHWC_, FP32_);
+  {
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 4, 5, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   2,   4,   6,   8,   10,  12,  14,  16,  18,  20,  22,  24,  26,
       28,  30,  32,  34,  36,  38,  40,  42,  44,  46,  48,  50,  52,  54,
@@ -1171,8 +1495,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 5, 2, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 5, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   5,   6,   7,   8,   10,  11,  12,  13,  15,  16,
       17,  18,  20,  21,  22,  23,  25,  26,  27,  28,  30,  31,  32,  33,
@@ -1189,8 +1518,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 4, 5, 1, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 4, 5, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   2,   4,   6,   4,   6,   8,   10,  12,  14,  16,  18,  16,  18,
       20,  22,  24,  26,  28,  30,  28,  30,  32,  34,  36,  38,  40,  42,
@@ -1207,8 +1541,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 1, 2, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 1, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   5,   6,   7,   8,   8,   9,   10,  11,  13,  14,
       15,  16,  16,  17,  18,  19,  21,  22,  23,  24,  24,  25,  26,  27,
@@ -1225,8 +1564,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(1, 4, 1, 2, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 4, 1, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   2,   4,   6,   8,   10,  12,  14,  8,   10,  12,  14,  16,  18,
       20,  22,  16,  18,  20,  22,  24,  26,  28,  30,  24,  26,  28,  30,
@@ -1243,8 +1587,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 5, 1, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 5, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   4,   5,   6,   7,   9,   10,  11,  12,  13,  14,
       15,  16,  18,  19,  20,  21,  22,  23,  24,  25,  27,  28,  29,  30,
@@ -1261,8 +1610,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(1, 1, 1, 2, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 1, 1, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   5,   6,   7,   8,   8,   9,   10,  11,  13,  14,
       15,  16,  16,  17,  18,  19,  21,  22,  23,  24,  24,  25,  26,  27,
@@ -1279,8 +1633,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(1, 4, 1, 1, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 4, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   2,   4,   6,   4,   6,   8,   10,  8,   10,  12,  14,  12,  14,
       16,  18,  16,  18,  20,  22,  20,  22,  24,  26,  24,  26,  28,  30,
@@ -1297,8 +1656,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 1, 1, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,
       14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,
@@ -1315,8 +1679,13 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_);
     nntrainer::Tensor m = ranged(1, 1, 1, 1, NHWC_);
+=======
+    nntrainer::Tensor t = ranged(3, 4, 5, 2, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     m.add_i(1.0);
     float answer_data[] = {
       1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,
@@ -1334,9 +1703,15 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 1, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 1, 4, NHWC_);
     nntrainer::Tensor m = ranged(3, 1, 1, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 1, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 1, 4, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 1, 1, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {0,  1,  2,  3,  4,  6,  7,  8,  9,  10, 12, 13,
                            14, 15, 16, 18, 19, 20, 21, 22, 24, 25, 26, 27,
                            28, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 42,
@@ -1348,9 +1723,15 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(1, 1, 2, 1, NHWC_);
     nntrainer::Tensor t = ranged(1, 1, 2, 1, NHWC_);
     nntrainer::Tensor m = ranged(1, 1, 2, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(1, 1, 2, 1, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(1, 1, 2, 1, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 1, 2, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {0.0, 2.0};
     nntrainer::Tensor answer(ref_dim, answer_data);
     int status = t.add_i(m);
@@ -1358,9 +1739,15 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
     EXPECT_EQ(t, answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(16, 1, 1, 1, NHWC_);
     nntrainer::Tensor t = ranged(16, 1, 1, 1, NHWC_);
     nntrainer::Tensor m = ranged(1, 1, 1, 1, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(16, 1, 1, 1, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(16, 1, 1, 1, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(1, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {0.0, 1.0, 2.0,  3.0,  4.0,  5.0,  6.0,  7.0,
                            8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0};
     nntrainer::Tensor answer(ref_dim, answer_data);
@@ -1371,15 +1758,25 @@ TEST(nntrainer_Tensor, add_i_broadcast_01_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, add_i_broadcast_not_supported_01_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 1, 3, 1, NHWC_);
   nntrainer::Tensor target2(3, 1, 3, 3, NHWC_);
+=======
+  nntrainer::Tensor target(3, 1, 3, 1, NHWC_, FP32_);
+  nntrainer::Tensor target2(3, 1, 3, 3, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_EQ(target.add_i(target2), ML_ERROR_INVALID_PARAMETER);
 }
 
 TEST(nntrainer_Tensor, add_i_broadcast_not_broadcastable_02_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 2, 4, 5, NHWC_);
   nntrainer::Tensor target2(3, 2, 3, 1, NHWC_);
+=======
+  nntrainer::Tensor target(3, 2, 4, 5, NHWC_, FP32_);
+  nntrainer::Tensor target2(3, 2, 3, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_EQ(target.add_i(target2), ML_ERROR_INVALID_PARAMETER);
 }
@@ -1391,7 +1788,11 @@ TEST(nntrainer_Tensor, add_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l);
@@ -1420,7 +1821,11 @@ TEST(nntrainer_Tensor, add_02_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
   nntrainer::Tensor result = input.add(input);
@@ -1448,11 +1853,19 @@ TEST(nntrainer_Tensor, add_03_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
 
   nntrainer::Tensor test(batch - 1, height - 1, width - 1, channel, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
+                               j * (width * channel) + k * channel + 1);
+
+  nntrainer::Tensor test(batch - 1, height - 1, width - 1, channel, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_THROW({ input.add(test); }, std::invalid_argument);
 }
@@ -1463,9 +1876,15 @@ TEST(nntrainer_Tensor, add_04_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
 
   nntrainer::Tensor input(batch, channel * 2, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+
+  nntrainer::Tensor input(batch, channel * 2, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor shared_input = input.getSharedDataTensor(dim, 0, false);
   nntrainer::Tensor test(dim);
 
@@ -1478,10 +1897,17 @@ TEST(nntrainer_Tensor, add_05_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, height, width, channel, NHWC_);
 
   nntrainer::Tensor input(dim);
   nntrainer::Tensor test(batch, height, width, channel * 2, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, height, width, channel, NHWC_, FP32_);
+
+  nntrainer::Tensor input(dim);
+  nntrainer::Tensor test(batch, height, width, channel * 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor shared_test = test.getSharedDataTensor(dim, 0, false);
 
   EXPECT_THROW(input.add(shared_test), std::invalid_argument);
@@ -1493,7 +1919,11 @@ TEST(nntrainer_Tensor, add_06_nhw_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, height, width, channel, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, height, width, channel, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim, false);
   nntrainer::Tensor test(dim);
@@ -1509,7 +1939,11 @@ TEST(nntrainer_Tensor, add_08_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, height, width, channel, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, height, width, channel, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
@@ -1526,11 +1960,16 @@ TEST(nntrainer_Tensor, add_08_nhwc_n) {
 
 TEST(nntrainer_Tensor, pow_01_nhwc_p) {
 
+<<<<<<< HEAD
   nntrainer::Tensor input = constant(4.0, 3, 2, 4, 5, NHWC_);
+=======
+  nntrainer::Tensor input = constant(4.0, 3, 2, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor actual, expected;
 
   actual = input.pow(0.5f);
+<<<<<<< HEAD
   expected = constant(2.0, 3, 2, 4, 5, NHWC_);
   EXPECT_EQ(actual, expected);
 
@@ -1540,6 +1979,17 @@ TEST(nntrainer_Tensor, pow_01_nhwc_p) {
 
   actual = input.pow(-0.5f);
   expected = constant(0.5, 3, 2, 4, 5, NHWC_);
+=======
+  expected = constant(2.0, 3, 2, 4, 5, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = input.pow(2.0f);
+  expected = constant(16.0, 3, 2, 4, 5, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = input.pow(-0.5f);
+  expected = constant(0.5, 3, 2, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(actual, expected);
 }
 
@@ -1550,7 +2000,11 @@ TEST(nntrainer_Tensor, subtract_i_01_nhwc_p) {
   int width = 10;
   int channel = 3;
 
+<<<<<<< HEAD
   nntrainer::Tensor target(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor target(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
                                 j * (width * channel) + k * channel + l);
 
@@ -1577,7 +2031,11 @@ TEST(nntrainer_Tensor, subtract_i_02_nhwc_p) {
   int width = 10;
   int channel = 3;
 
+<<<<<<< HEAD
   nntrainer::Tensor target(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor target(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
                                 j * (width * channel) + k * channel + l);
 
@@ -1599,11 +2057,19 @@ TEST(nntrainer_Tensor, subtract_i_03_nhwc_n) {
   int width = 10;
   int channel = 3;
 
+<<<<<<< HEAD
   nntrainer::Tensor target(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
                                 j * (width * channel) + k * channel + l);
 
   nntrainer::Tensor target2(batch, height, width - 3, channel - 1, NHWC_);
+=======
+  nntrainer::Tensor target(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
+                                j * (width * channel) + k * channel + l);
+
+  nntrainer::Tensor target2(batch, height, width - 3, channel - 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   status = target.subtract_i(target2);
   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
@@ -1616,7 +2082,11 @@ TEST(nntrainer_Tensor, subtract_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
 
@@ -1643,13 +2113,21 @@ TEST(nntrainer_Tensor, subtract_02_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
 
   nntrainer::Tensor result = input.subtract(input);
 
+<<<<<<< HEAD
   EXPECT_EQ(constant(0.0, batch, channel, height, width, NHWC_), result);
+=======
+  EXPECT_EQ(constant(0.0, batch, channel, height, width, NHWC_, FP32_), result);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 }
 
 TEST(nntrainer_Tensor, subtract_03_nhwc_n) {
@@ -1658,11 +2136,19 @@ TEST(nntrainer_Tensor, subtract_03_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
 
   nntrainer::Tensor test(batch - 1, channel - 1, height, width - 1, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
+                               j * (width * channel) + k * channel + 1);
+
+  nntrainer::Tensor test(batch - 1, channel - 1, height, width - 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_THROW({ input.subtract(test); }, std::invalid_argument);
 }
@@ -1673,9 +2159,15 @@ TEST(nntrainer_Tensor, subtract_04_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
 
   nntrainer::Tensor input(batch, 2 * channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+
+  nntrainer::Tensor input(batch, 2 * channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor shared_input = input.getSharedDataTensor(dim, 0, false);
   nntrainer::Tensor test(dim);
 
@@ -1688,10 +2180,17 @@ TEST(nntrainer_Tensor, subtract_05_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
 
   nntrainer::Tensor input(dim);
   nntrainer::Tensor test(batch, 2 * channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+
+  nntrainer::Tensor input(dim);
+  nntrainer::Tensor test(batch, 2 * channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor shared_test = test.getSharedDataTensor(dim, 0, false);
 
   EXPECT_THROW(input.subtract(shared_test), std::invalid_argument);
@@ -1703,7 +2202,11 @@ TEST(nntrainer_Tensor, subtract_06_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim, false);
   nntrainer::Tensor test(dim);
@@ -1719,7 +2222,11 @@ TEST(nntrainer_Tensor, subtract_07_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
@@ -1736,7 +2243,11 @@ TEST(nntrainer_Tensor, subtract_08_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
@@ -1757,11 +2268,19 @@ TEST(nntrainer_Tensor, subtract_float_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
 
   nntrainer::Tensor expected(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
+                               j * (width * channel) + k * channel + 1);
+
+  nntrainer::Tensor expected(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(expected, i * (height * width * channel) +
                                   j * (width * channel) + k * channel);
 
@@ -1776,7 +2295,11 @@ TEST(nntrainer_Tensor, sum_01_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l);
@@ -1790,7 +2313,11 @@ TEST(nntrainer_Tensor, sum_02_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + l);
 
@@ -1824,7 +2351,11 @@ TEST(nntrainer_Tensor, sum_02_nhwc_p) {
                                                                  {225, 228},
                                                                  {231, 234},
                                                                  {237, 240}}}}),
+<<<<<<< HEAD
     NHWC_);
+=======
+    NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor ans1(
     std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -1843,7 +2374,11 @@ TEST(nntrainer_Tensor, sum_02_nhwc_p) {
          {231},
          {235},
          {239}}}}),
+<<<<<<< HEAD
     NHWC_);
+=======
+    NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor ans2(
     std::vector<std::vector<std::vector<std::vector<float>>>>({{{{22, 24},
@@ -1876,16 +2411,26 @@ TEST(nntrainer_Tensor, sum_02_nhwc_p) {
                                                                  {210, 212},
                                                                  {214, 216},
                                                                  {218, 220}}}}),
+<<<<<<< HEAD
     NHWC_);
+=======
+    NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor ans3(
     std::vector<std::vector<std::vector<std::vector<float>>>>(
       {{{{100, 110}}, {{300, 310}}},
        {{{500, 510}}, {{700, 710}}},
        {{{900, 910}}, {{1100, 1110}}}}),
+<<<<<<< HEAD
     NHWC_);
 
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+    NHWC_, FP32_);
+
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * (channel) + l + 1);
 
@@ -1906,7 +2451,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
   const int height = 2;
   const int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * channel * width) +
                                j * (width * channel) + k * (channel) + l + 1);
   // Test for alpha == 1 and beta == 0 and dimension of reduced axis == 1
@@ -1933,7 +2482,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {225, 228},
            {231, 234},
            {237, 240}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_1_1_0(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -1971,7 +2524,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {231},
            {235},
            {239}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_2_1_0(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2006,14 +2563,22 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {210, 212},
            {214, 216},
            {218, 220}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_3_1_0(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
         {{{{100, 110}}, {{300, 310}}},
          {{{500, 510}}, {{700, 710}}},
          {{{900, 910}}, {{1100, 1110}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor result_0_1_0 = input.sum(0, 1);
     nntrainer::Tensor result_1_1_0 = input.sum(1, 1);
@@ -2050,7 +2615,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {295, 300},
            {305, 310},
            {315, 320}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_1_1_2(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2096,7 +2665,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {347},
            {353},
            {359}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_2_1_2(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2130,7 +2703,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {320, 324},
            {328, 332},
            {336, 340}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_3_1_2(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2138,30 +2715,48 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
         {{{{102, 114}}, {{306, 318}}},
          {{{510, 522}}, {{714, 726}}},
          {{{918, 930}}, {{1122, 1134}}}}),
+<<<<<<< HEAD
       NHWC_);
 
     nntrainer::Tensor output_0_1_2(1, channel, height, width, NHWC_);
+=======
+      NHWC_, FP32_);
+
+    nntrainer::Tensor output_0_1_2(1, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     {
       const int batch = 1;
       GEN_TEST_INPUT_NHWC(output_0_1_2, i * (channel * height * width) +
                                           j * (width * channel) +
                                           k * (channel) + l + 1);
     }
+<<<<<<< HEAD
     nntrainer::Tensor output_1_1_2(batch, 1, height, width, NHWC_);
+=======
+    nntrainer::Tensor output_1_1_2(batch, 1, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     {
       const int channel = 1;
       GEN_TEST_INPUT_NHWC(output_1_1_2, i * (channel * height * width) +
                                           j * (width * channel) +
                                           k * (channel) + l + 1);
     }
+<<<<<<< HEAD
     nntrainer::Tensor output_2_1_2(batch, channel, 1, width, NHWC_);
+=======
+    nntrainer::Tensor output_2_1_2(batch, channel, 1, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     {
       const int height = 1;
       GEN_TEST_INPUT_NHWC(output_2_1_2, i * (channel * height * width) +
                                           j * (width * channel) +
                                           k * (channel) + l + 1);
     }
+<<<<<<< HEAD
     nntrainer::Tensor output_3_1_2(batch, channel, height, 1, NHWC_);
+=======
+    nntrainer::Tensor output_3_1_2(batch, channel, height, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     {
       const int width = 1;
       GEN_TEST_INPUT_NHWC(output_3_1_2, i * (channel * height * width) +
@@ -2203,7 +2798,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {450, 456},
            {462, 468},
            {474, 480}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_1_2_0(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2249,7 +2848,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {462},
            {470},
            {478}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_2_2_0(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2284,7 +2887,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {420, 424},
            {428, 432},
            {436, 440}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_3_2_0(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2292,7 +2899,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
         {{{{200, 220}}, {{600, 620}}},
          {{{1000, 1020}}, {{1400, 1420}}},
          {{{1800, 1820}}, {{2200, 2220}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor result_0_2_0 = input.sum(0, 2);
     nntrainer::Tensor result_1_2_0 = input.sum(1, 2);
@@ -2329,7 +2940,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {520, 528},
            {536, 544},
            {552, 560}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_1_2_2(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2384,7 +2999,11 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {578},
            {588},
            {598}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_2_2_2(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
@@ -2418,37 +3037,59 @@ TEST(nntrainer_Tensor, sum_03_nhwc_p) {
            {530, 536},
            {542, 548},
            {554, 560}}}}),
+<<<<<<< HEAD
       NHWC_);
+=======
+      NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
     nntrainer::Tensor ans_3_2_2(
       std::vector<std::vector<std::vector<std::vector<float>>>>(
         {{{{202, 224}}, {{606, 628}}},
          {{{1010, 1032}}, {{1414, 1436}}},
          {{{1818, 1840}}, {{2222, 2244}}}}),
+<<<<<<< HEAD
       NHWC_);
 
     nntrainer::Tensor output_0_2_2(1, channel, height, width, NHWC_);
+=======
+      NHWC_, FP32_);
+
+    nntrainer::Tensor output_0_2_2(1, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     {
       const int batch = 1;
       GEN_TEST_INPUT_NHWC(output_0_2_2, i * (channel * height * width) +
                                           j * (channel * width) +
                                           k * (channel) + l + 1);
     }
+<<<<<<< HEAD
     nntrainer::Tensor output_1_2_2(batch, 1, height, width, NHWC_);
+=======
+    nntrainer::Tensor output_1_2_2(batch, 1, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     {
       const int channel = 1;
       GEN_TEST_INPUT_NHWC(output_1_2_2, i * (channel * height * width) +
                                           j * (channel * width) +
                                           k * (channel) + l + 1);
     }
+<<<<<<< HEAD
     nntrainer::Tensor output_2_2_2(batch, channel, 1, width, NHWC_);
+=======
+    nntrainer::Tensor output_2_2_2(batch, channel, 1, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     {
       const int height = 1;
       GEN_TEST_INPUT_NHWC(output_2_2_2, i * (channel * height * width) +
                                           j * (channel * width) +
                                           k * (channel) + l + 1);
     }
+<<<<<<< HEAD
     nntrainer::Tensor output_3_2_2(batch, channel, height, 1, NHWC_);
+=======
+    nntrainer::Tensor output_3_2_2(batch, channel, height, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     {
       const int width = 1;
       GEN_TEST_INPUT_NHWC(output_3_2_2, i * (channel * height * width) +
@@ -2473,7 +3114,11 @@ TEST(nntrainer_Tensor, sum_04_nhwc_p) {
   int height = 2;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (channel * width) + k * channel + l + 1);
 
@@ -2487,16 +3132,25 @@ TEST(nntrainer_Tensor, sum_04_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, multiple_sum_invalid_args_01_hnwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 1, 1, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 1, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.sum(std::vector<unsigned int>()), std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, multiple_sum_out_of_range_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 1, 1, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 1, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.sum({7}), std::out_of_range);
 }
 
 TEST(nntrainer_Tensor, multiple_sum_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 2, 3, 5, 7, NHWC_);
   nntrainer::Tensor actual, expected;
 
@@ -2514,28 +3168,63 @@ TEST(nntrainer_Tensor, multiple_sum_nhwc_p) {
 
   actual = t.sum({3, 1}, 0.5);
   expected = constant(7 * 3 * 0.5, 2, 1, 5, 1, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 2, 3, 5, 7, NHWC_, FP32_);
+  nntrainer::Tensor actual, expected;
+
+  actual = t.sum({0, 1});
+  expected = constant(2 * 3, 1, 1, 5, 7, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.sum({1, 2, 3});
+  expected = constant(3 * 5 * 7, 2, 1, 1, 1, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.sum({3, 1});
+  expected = constant(7 * 3, 2, 1, 5, 1, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.sum({3, 1}, 0.5);
+  expected = constant(7 * 3 * 0.5, 2, 1, 5, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(actual, expected);
 }
 
 TEST(nntrainer_Tensor, average_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 2, 3, 5, 7, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 2, 3, 5, 7, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor actual, expected;
 
   actual = t.average();
+<<<<<<< HEAD
   expected = constant(1.0, 1, 1, 1, 1, NHWC_);
+=======
+  expected = constant(1.0, 1, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(actual, expected);
 
   int idx = 0;
   t = t.apply([&](float in) { return idx++ % 2; });
 
   actual = t.average();
+<<<<<<< HEAD
   expected = constant(0.5, 1, 1, 1, 1, NHWC_);
+=======
+  expected = constant(0.5, 1, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(actual, expected);
 }
 
 TEST(nntrainer_Tensor, average_axis_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 2, 2, 2, 2, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 2, 2, 2, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   int idx = 0;
   std::function<float(float)> f = [&](float in) { return idx++ % 2; };
   t = t.apply(f);
@@ -2543,6 +3232,7 @@ TEST(nntrainer_Tensor, average_axis_nhwc_p) {
   nntrainer::Tensor actual, expected;
 
   actual = t.average(0);
+<<<<<<< HEAD
   expected = constant(0, 1, 2, 2, 2, NHWC_).apply(f);
   EXPECT_EQ(actual, expected);
 
@@ -2556,20 +3246,44 @@ TEST(nntrainer_Tensor, average_axis_nhwc_p) {
 
   actual = t.average(3);
   expected = constant(0, 2, 2, 2, 1, NHWC_).apply(f);
+=======
+  expected = constant(0, 1, 2, 2, 2, NHWC_, FP32_).apply(f);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.average(1);
+  expected = constant(0.5, 2, 1, 2, 2, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.average(2);
+  expected = constant(0, 2, 2, 1, 2, NHWC_, FP32_).apply(f);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.average(3);
+  expected = constant(0, 2, 2, 2, 1, NHWC_, FP32_).apply(f);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(actual, expected);
 }
 
 TEST(nntrainer_Tensor, average_axis_out_of_range_01_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 2, 2, 2, 2, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 2, 2, 2, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.average(-1), std::out_of_range);
 }
 
 TEST(nntrainer_Tensor, average_axis_out_of_range_02_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 2, 2, 2, 2, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 2, 2, 2, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.average(7), std::out_of_range);
 }
 
 TEST(nntrainer_Tensor, average_multiple_axes_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 2, 3, 5, 7, NHWC_);
   nntrainer::Tensor actual, expected;
 
@@ -2587,11 +3301,34 @@ TEST(nntrainer_Tensor, average_multiple_axes_nhwc_p) {
 
   actual = t.average({3, 1, 1, 1, 3});
   expected = constant(1.0, 2, 1, 5, 1, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 2, 3, 5, 7, NHWC_, FP32_);
+  nntrainer::Tensor actual, expected;
+
+  actual = t.average({0, 1, 2});
+  expected = constant(1.0, 1, 1, 1, 7, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.average({0, 1, 2, 3});
+  expected = constant(1.0, 1, 1, 1, 1, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.average({3, 1});
+  expected = constant(1.0, 2, 1, 5, 1, NHWC_, FP32_);
+  EXPECT_EQ(actual, expected);
+
+  actual = t.average({3, 1, 1, 1, 3});
+  expected = constant(1.0, 2, 1, 5, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(actual, expected);
 }
 
 TEST(nntrainer_Tensor, average_multiple_axes_01_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t = constant(1.0, 2, 3, 5, 7, NHWC_);
+=======
+  nntrainer::Tensor t = constant(1.0, 2, 3, 5, 7, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.average({5, 7}), std::out_of_range);
 }
 
@@ -2600,7 +3337,11 @@ TEST(nntrainer_Tensor, average_multiple_axes_01_nhwc_n) {
 TEST(nntrainer_Tensor,
      constructor_from_shared_const_ptr_shares_variable_nhwc_n) {
   nntrainer::sharedConstTensor A =
+<<<<<<< HEAD
     MAKE_SHARED_TENSOR(constant(1.0f, 3, 4, 5, 6, NHWC_));
+=======
+    MAKE_SHARED_TENSOR(constant(1.0f, 3, 4, 5, 6, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor B = *A;
   nntrainer::Tensor C = A->clone();
@@ -2609,39 +3350,68 @@ TEST(nntrainer_Tensor,
   EXPECT_EQ(*A, B);
   EXPECT_NE(*A, C);
 
+<<<<<<< HEAD
   C.reshape(nntrainer::TensorDim(3, 4, 6, 5, NHWC_));
+=======
+  C.reshape(nntrainer::TensorDim(3, 4, 6, 5, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(A->getDim(), B.getDim());
   EXPECT_NE(A->getDim(), C.getDim());
 }
 
 TEST(nntrainer_Tensor, dot_01_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor input(2, 4, 5, 3, NHWC_);
   nntrainer::Tensor m(1, 4, 5, 3, NHWC_);
+=======
+  nntrainer::Tensor input(2, 4, 5, 3, NHWC_, FP32_);
+  nntrainer::Tensor m(1, 4, 5, 3, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(nntrainer::Tensor result = input.dot(m), std::runtime_error);
 }
 
 TEST(nntrainer_Tensor, dot_02_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor input(2, 3, 4, 5, NHWC_);
   nntrainer::Tensor m(1, 3, 4, 5, NHWC_);
+=======
+  nntrainer::Tensor input(2, 3, 4, 5, NHWC_, FP32_);
+  nntrainer::Tensor m(1, 3, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(nntrainer::Tensor result = input.dot(m, true),
                std::runtime_error);
 }
 
 TEST(nntrainer_Tensor, dot_02_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor input(2, 3, 4, 5, NHWC_);
   nntrainer::Tensor m(1, 3, 4, 5, NHWC_);
+=======
+  nntrainer::Tensor input(2, 3, 4, 5, NHWC_, FP32_);
+  nntrainer::Tensor m(1, 3, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_NO_THROW(nntrainer::Tensor result = input.dot(m, false, true));
 }
 
 TEST(nntrainer_Tensor, dot_03_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor input(1, 3, 4, 5, NHWC_);
   nntrainer::Tensor m(1, 3, 4, 5, NHWC_);
+=======
+  nntrainer::Tensor input(1, 3, 4, 5, NHWC_, FP32_);
+  nntrainer::Tensor m(1, 3, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_NO_THROW(nntrainer::Tensor result = input.dot(m, true));
 }
 
 TEST(nntrainer_Tensor, dot_04_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor input(2, 4, 5, 3, NHWC_);
   nntrainer::Tensor m(1, 4, 5, 1, NHWC_);
+=======
+  nntrainer::Tensor input(2, 4, 5, 3, NHWC_, FP32_);
+  nntrainer::Tensor m(1, 4, 5, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(nntrainer::Tensor result = input.dot(m), std::runtime_error);
   EXPECT_NO_THROW(nntrainer::Tensor result = input.dot(m, false, true));
 }
@@ -2654,16 +3424,28 @@ TEST(nntrainer_Tensor, dot_05_nhwc_p) {
   int width = 5;
   float ans[2][4][5][40] = {0};
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * (channel) + l + 1);
 
+<<<<<<< HEAD
   nntrainer::Tensor weight(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(weight, i * (height * width * channel) +
                                 j * (width * channel) + k * (channel) + l + 1);
 
   weight.reshape(nntrainer::TensorDim(1, 3, 8, 5, NHWC_));
+=======
+  nntrainer::Tensor weight(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(weight, i * (height * width * channel) +
+                                j * (width * channel) + k * (channel) + l + 1);
+
+  weight.reshape(nntrainer::TensorDim(1, 3, 8, 5, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor result = input.dot(weight, false, true);
 
@@ -2709,7 +3491,11 @@ TEST(nntrainer_Tensor, dot_06_nhwc_p) {
   float ans[3][1][1][3] = {
     {{{30, 36, 42}}}, {{{66, 81, 96}}}, {{{102, 126, 150}}}};
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * (channel) + l + 1);
 
@@ -2732,180 +3518,312 @@ end_dot_01_p:
 TEST(nntrainer_Tensor, dot_transpose_nhwc_p) {
   {
     float a_data[] = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), b_data);
     float answer_data[] = {20, 23,  26,  29,  56,  68,  80,  92,
                            92, 113, 134, 155, 128, 158, 188, 218};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23,  26,  29,  56,  68,  80,  92,
+                           92, 113, 134, 155, 128, 158, 188, 218};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), b_data);
     float answer_data[] = {20, 23,  26,  29,  56,  68,  80,  92,
                            92, 113, 134, 155, 128, 158, 188, 218};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23,  26,  29,  56,  68,  80,  92,
+                           92, 113, 134, 155, 128, 158, 188, 218};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), a_data);
     float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), b_data);
     float answer_data[] = {20, 23,  26,  29,  56,  68,  80,  92,
                            92, 113, 134, 155, 128, 158, 188, 218};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23,  26,  29,  56,  68,  80,  92,
+                           92, 113, 134, 155, 128, 158, 188, 218};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), b_data);
     float answer_data[] = {20, 23,  26,  29,  56,  68,  80,  92,
                            92, 113, 134, 155, 128, 158, 188, 218};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23,  26,  29,  56,  68,  80,  92,
+                           92, 113, 134, 155, 128, 158, 188, 218};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 1, 4, 2, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29, 56, 68, 80, 92};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29, 56, 68, 80, 92};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 1, 4, 2, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29, 56, 68, 80, 92};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29, 56, 68, 80, 92};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), a_data);
     float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29, 56, 68, 80, 92};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29, 56, 68, 80, 92};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29, 56, 68, 80, 92};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29, 56, 68, 80, 92};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 2, 4, 1, 3, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), b_data);
     float answer_data[] = {10, 13, 28, 40, 46, 67, 64, 94};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 2, 4, 1, 3, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13, 28, 40, 46, 67, 64, 94};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), b_data);
     float answer_data[] = {10, 13, 28, 40, 46, 67, 64, 94};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13, 28, 40, 46, 67, 64, 94};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), a_data);
     float b_data[] = {0, 2, 4, 1, 3, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), b_data);
     float answer_data[] = {10, 13, 28, 40, 46, 67, 64, 94};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 2, 4, 1, 3, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13, 28, 40, 46, 67, 64, 94};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), b_data);
     float answer_data[] = {10, 13, 28, 40, 46, 67, 64, 94};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13, 28, 40, 46, 67, 64, 94};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 1, 4, 2, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 2, 4, 1, 3, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), b_data);
     float answer_data[] = {10, 13, 28, 40};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 2, 4, 1, 3, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13, 28, 40};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 1, 4, 2, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), b_data);
     float answer_data[] = {10, 13, 28, 40};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13, 28, 40};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), a_data);
     float b_data[] = {0, 2, 4, 1, 3, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), b_data);
     float answer_data[] = {10, 13, 28, 40};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 2, 4, 1, 3, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13, 28, 40};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), b_data);
     float answer_data[] = {10, 13, 28, 40};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13, 28, 40};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
@@ -2915,264 +3833,456 @@ TEST(nntrainer_Tensor, dot_transpose_nhwc_p) {
 TEST(nntrainer_Tensor, dot_shortcuts_nhwc_p) {
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), b_data);
     float answer_data[] = {5};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), b_data);
     float answer_data[] = {5};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), b_data);
     float answer_data[] = {5};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), b_data);
     float answer_data[] = {5};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), b_data);
     float answer_data[] = {5, 14};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5, 14};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 1, 4, 2, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), b_data);
     float answer_data[] = {5, 14};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5, 14};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), b_data);
     float answer_data[] = {5, 14};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5, 14};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 1, 4, 2, 5};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), b_data);
     float answer_data[] = {5, 14};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 2, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5, 14};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 2, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), b_data);
     float answer_data[] = {5, 14, 23, 32};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5, 14, 23, 32};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), b_data);
     float answer_data[] = {5, 14, 23, 32};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5, 14, 23, 32};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), b_data);
     float answer_data[] = {5, 14, 23, 32};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5, 14, 23, 32};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), b_data);
     float answer_data[] = {5, 14, 23, 32};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 4, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {5, 14, 23, 32};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 1, 4, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), a_data);
     float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 4, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), a_data);
     float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_), b_data);
     float answer_data[] = {20, 23, 26, 29};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 4, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {20, 23, 26, 29};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 4, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), b_data);
     float answer_data[] = {10, 13};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 1, 2, 3, 4, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_), b_data);
     float answer_data[] = {10, 13};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 1, 2, 3, 4, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 2, 3, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, false);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_), a_data);
     float b_data[] = {0, 2, 4, 1, 3, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), b_data);
     float answer_data[] = {10, 13};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 3, 1, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 2, 4, 1, 3, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, false, true);
     EXPECT_EQ(ret, answer);
   }
   {
     float a_data[] = {0, 1, 2};
+<<<<<<< HEAD
     nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_), a_data);
     float b_data[] = {0, 2, 4, 1, 3, 5};
     nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_), b_data);
     float answer_data[] = {10, 13};
     nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 1, 1, NHWC_),
+=======
+    nntrainer::Tensor a(nntrainer::TensorDim(1, 1, 3, 1, NHWC_, FP32_), a_data);
+    float b_data[] = {0, 2, 4, 1, 3, 5};
+    nntrainer::Tensor b(nntrainer::TensorDim(1, 3, 2, 1, NHWC_, FP32_), b_data);
+    float answer_data[] = {10, 13};
+    nntrainer::Tensor answer(nntrainer::TensorDim(1, 2, 1, 1, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor ret = a.dot(b, true, true);
     EXPECT_EQ(ret, answer);
@@ -3186,13 +4296,21 @@ TEST(nntrainer_Tensor, empty_nhwc_01) {
 }
 
 TEST(nntrainer_Tensor, empty_nhwc_02) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), false);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), false);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_FALSE(t.empty());
 }
 
 TEST(nntrainer_Tensor, empty_nhwc_03) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), true);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), true);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_FALSE(t.empty());
 }
@@ -3200,8 +4318,13 @@ TEST(nntrainer_Tensor, empty_nhwc_03) {
 TEST(nntrainer_Tensor, fill_p) {
   /// same dimension, buffer size
   {
+<<<<<<< HEAD
     nntrainer::Tensor target(3, 2, 4, 5, NHWC_);
     nntrainer::Tensor original = randUniform(3, 2, 4, 5, -1.0f, 1.0f, NHWC_);
+=======
+    nntrainer::Tensor target(3, 2, 4, 5, NHWC_, FP32_);
+    nntrainer::Tensor original = randUniform(3, 2, 4, 5, -1.0f, 1.0f, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     target.fill(original, false);
 
     EXPECT_EQ(target, original);
@@ -3216,7 +4339,11 @@ TEST(nntrainer_Tensor, fill_p) {
   /// uninitialized with initialized flag is true
   {
     nntrainer::Tensor target;
+<<<<<<< HEAD
     nntrainer::Tensor original = randUniform(3, 2, 4, 5, -1.0f, 1.0f, NHWC_);
+=======
+    nntrainer::Tensor original = randUniform(3, 2, 4, 5, -1.0f, 1.0f, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     target.fill(original, true);
 
     EXPECT_EQ(target, original);
@@ -3225,13 +4352,22 @@ TEST(nntrainer_Tensor, fill_p) {
 
 TEST(nntrainer_Tensor, fill_uninitialized_n) {
   nntrainer::Tensor target;
+<<<<<<< HEAD
   nntrainer::Tensor original = randUniform(3, 1, 2, 3, -1.0f, 1.0f, NHWC_);
+=======
+  nntrainer::Tensor original = randUniform(3, 1, 2, 3, -1.0f, 1.0f, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(target.fill(original, false), std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, fill_different_dimension_n) {
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 1, 3, 2, NHWC_);
   nntrainer::Tensor original = randUniform(3, 1, 2, 3, -1.0f, 1.0f, NHWC_);
+=======
+  nntrainer::Tensor target(3, 1, 3, 2, NHWC_, FP32_);
+  nntrainer::Tensor original = randUniform(3, 1, 2, 3, -1.0f, 1.0f, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(target.fill(original, false), std::invalid_argument);
 }
 
@@ -3253,7 +4389,11 @@ TEST(nntrainer_Tensor, add_strided_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
   nntrainer::Tensor result = input.add_strided(input);
@@ -3287,11 +4427,19 @@ TEST(nntrainer_Tensor, add_strided_02_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
 
   nntrainer::Tensor test(batch - 1, height - 1, width - 1, channel, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
+                               j * (width * channel) + k * channel + 1);
+
+  nntrainer::Tensor test(batch - 1, height - 1, width - 1, channel, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_THROW({ input.add_strided(test); }, std::invalid_argument);
 }
@@ -3302,7 +4450,11 @@ TEST(nntrainer_Tensor, add_strided_03_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, height, width, channel, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, height, width, channel, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim, false);
   nntrainer::Tensor test(dim);
@@ -3318,7 +4470,11 @@ TEST(nntrainer_Tensor, add_strided_04_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, height, width, channel, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, height, width, channel, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
@@ -3340,7 +4496,11 @@ TEST(nntrainer_Tensor, add_strided_05_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
                                j * (width * channel) + k * channel + 1);
   nntrainer::Tensor result = input.add_strided(input, 10.0);
@@ -3381,7 +4541,11 @@ TEST(nntrainer_Tensor, multiply_strided_01_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(input, i * (batch * height * width) +
                                j * (height * width) + k + 1);
 
@@ -3415,11 +4579,19 @@ TEST(nntrainer_Tensor, multiply_strided_02_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (height * width) + j * (height * width) +
                                k * width + l);
 
   nntrainer::Tensor test(batch - 1, height - 1, width - 1, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (height * width) + j * (height * width) +
+                               k * width + l);
+
+  nntrainer::Tensor test(batch - 1, height - 1, width - 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_THROW({ input.multiply_strided(test); }, std::invalid_argument);
 }
@@ -3430,7 +4602,11 @@ TEST(nntrainer_Tensor, multiply_strided_03_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   // input is not allocated now : alloc_now == false
   nntrainer::Tensor input(dim, false);
   nntrainer::Tensor test(dim);
@@ -3446,7 +4622,11 @@ TEST(nntrainer_Tensor, multiply_strided_04_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
@@ -3463,7 +4643,11 @@ TEST(nntrainer_Tensor, multiply_strided_05_nhwc_n) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::TensorDim dim(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::TensorDim dim(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   nntrainer::Tensor input(dim);
   GEN_TEST_INPUT_NHWC(input, i * (height * width * channel) +
@@ -3484,11 +4668,19 @@ TEST(nntrainer_Tensor, multiply_strided_06_nhwc_p) {
   int height = 3;
   int width = 10;
 
+<<<<<<< HEAD
   nntrainer::Tensor input(batch, channel, height, width, NHWC_);
   GEN_TEST_INPUT_NHWC(input, i * (batch * height * width) +
                                j * (height * width) + k + 1);
 
   nntrainer::Tensor output(batch, channel, height, width, NHWC_);
+=======
+  nntrainer::Tensor input(batch, channel, height, width, NHWC_, FP32_);
+  GEN_TEST_INPUT_NHWC(input, i * (batch * height * width) +
+                               j * (height * width) + k + 1);
+
+  nntrainer::Tensor output(batch, channel, height, width, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   GEN_TEST_INPUT_NHWC(output, i * (batch * height * width) +
                                 j * (height * width) + k + 1);
 
@@ -3536,7 +4728,11 @@ TEST(nntrainer_Tensor, allocate_01_nhwc_n) {
 }
 
 TEST(nntrainer_Tensor, allocate_02_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), false);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), false);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_FALSE(t.isAllocated());
 
   t.allocate();
@@ -3544,7 +4740,11 @@ TEST(nntrainer_Tensor, allocate_02_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, allocate_03_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), true);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), true);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_TRUE(t.isAllocated());
 
   t.allocate();
@@ -3552,19 +4752,32 @@ TEST(nntrainer_Tensor, allocate_03_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, initialize_01_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), true,
                       nntrainer::Tensor::Initializer::ONES);
 
   nntrainer::Tensor golden(1, 2, 3, 4, NHWC_);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), true,
+                      nntrainer::Tensor::Initializer::ONES);
+
+  nntrainer::Tensor golden(1, 2, 3, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   golden.setValue(1);
 
   EXPECT_EQ(golden, t);
 }
 
 TEST(nntrainer_Tensor, initialize_02_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), true);
 
   nntrainer::Tensor golden(1, 2, 3, 4, NHWC_);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), true);
+
+  nntrainer::Tensor golden(1, 2, 3, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   golden.setValue(1);
 
   EXPECT_NE(golden, t);
@@ -3574,32 +4787,55 @@ TEST(nntrainer_Tensor, initialize_02_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, initialize_03_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), false,
                       nntrainer::Tensor::Initializer::ONES);
   t.allocate();
 
   nntrainer::Tensor golden(1, 2, 3, 4, NHWC_);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), false,
+                      nntrainer::Tensor::Initializer::ONES);
+  t.allocate();
+
+  nntrainer::Tensor golden(1, 2, 3, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   golden.setValue(1);
 
   EXPECT_EQ(golden, t);
 }
 
 TEST(nntrainer_Tensor, initialize_04_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), false);
   t.initialize(nntrainer::Tensor::Initializer::ONES);
   t.allocate();
 
   nntrainer::Tensor golden(1, 2, 3, 4, NHWC_);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), false);
+  t.initialize(nntrainer::Tensor::Initializer::ONES);
+  t.allocate();
+
+  nntrainer::Tensor golden(1, 2, 3, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   golden.setValue(1);
 
   EXPECT_EQ(golden, t);
 }
 
 TEST(nntrainer_Tensor, initialize_05_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), false);
   t.allocate();
 
   nntrainer::Tensor golden(1, 2, 3, 4, NHWC_);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), false);
+  t.allocate();
+
+  nntrainer::Tensor golden(1, 2, 3, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   golden.setValue(1.f);
 
   /**
@@ -3612,9 +4848,15 @@ TEST(nntrainer_Tensor, initialize_05_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, initialize_06_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), true,
                       nntrainer::Tensor::Initializer::ONES);
   nntrainer::Tensor golden(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), true,
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), true,
+                      nntrainer::Tensor::Initializer::ONES);
+  nntrainer::Tensor golden(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), true,
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                            nntrainer::Tensor::Initializer::ZEROS);
 
   EXPECT_NE(golden, t);
@@ -3624,10 +4866,17 @@ TEST(nntrainer_Tensor, initialize_06_nhwc_n) {
 }
 
 TEST(nntrainer_Tensor, initialize_07_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), true,
                       nntrainer::Tensor::Initializer::ONES);
 
   nntrainer::Tensor golden(1, 2, 3, 4, NHWC_);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), true,
+                      nntrainer::Tensor::Initializer::ONES);
+
+  nntrainer::Tensor golden(1, 2, 3, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   golden.setValue(1);
 
   EXPECT_EQ(golden, t);
@@ -3641,10 +4890,17 @@ TEST(nntrainer_Tensor, initialize_07_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, initialize_08_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_), true,
                       nntrainer::Tensor::Initializer::ONES);
 
   nntrainer::Tensor golden(1, 2, 3, 4, NHWC_);
+=======
+  nntrainer::Tensor t(nntrainer::TensorDim(1, 2, 3, 4, NHWC_, FP32_), true,
+                      nntrainer::Tensor::Initializer::ONES);
+
+  nntrainer::Tensor golden(1, 2, 3, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   golden.setValue(1);
 
   EXPECT_EQ(golden, t);
@@ -3663,14 +4919,24 @@ TEST(nntrainer_Tensor, initialize_08_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, reshape_01_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor A = constant(1.0f, 3, 4, 5, 6, NHWC_);
 
   EXPECT_THROW(A.reshape(nntrainer::TensorDim(9, 9, 9, 9, NHWC_)),
+=======
+  nntrainer::Tensor A = constant(1.0f, 3, 4, 5, 6, NHWC_, FP32_);
+
+  EXPECT_THROW(A.reshape(nntrainer::TensorDim(9, 9, 9, 9, NHWC_, FP32_)),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, reshape_02_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor A = constant(1.0f, 3, 4, 5, 6, NHWC_);
+=======
+  nntrainer::Tensor A = constant(1.0f, 3, 4, 5, 6, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::TensorDim A_dim = A.getDim();
 
   /** Changing the dim of a tensor only affects local copy of the dim */
@@ -3686,8 +4952,13 @@ TEST(nntrainer_Tensor, save_read_01_nhwc_p) {
   int channel = 4;
   int height = 5;
   int width = 6;
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 4, 5, 6, NHWC_);
   nntrainer::Tensor readed(3, 4, 5, 6, NHWC_);
+=======
+  nntrainer::Tensor target(3, 4, 5, 6, NHWC_, FP32_);
+  nntrainer::Tensor readed(3, 4, 5, 6, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
                                 j * (width * channel) + k * channel + 1);
@@ -3712,8 +4983,13 @@ TEST(nntrainer_Tensor, save_read_02_nhwc_n) {
   int channel = 4;
   int height = 5;
   int width = 6;
+<<<<<<< HEAD
   nntrainer::Tensor target(3, 4, 5, 6, NHWC_);
   nntrainer::Tensor readed(3, 4, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor target(3, 4, 5, 6, NHWC_, FP32_);
+  nntrainer::Tensor readed(3, 4, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   GEN_TEST_INPUT_NHWC(target, i * (height * width * channel) +
                                 j * (width * channel) + k * channel + 1);
@@ -3734,7 +5010,11 @@ TEST(nntrainer_Tensor, save_read_02_nhwc_n) {
 }
 
 TEST(nntrainer_Tensor, set_01_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor tensor = nntrainer::Tensor(1, 1, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor tensor = nntrainer::Tensor(1, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   tensor.setZero();
   EXPECT_EQ(tensor.getValue(0, 0, 0, 0), 0.0);
@@ -3745,7 +5025,11 @@ TEST(nntrainer_Tensor, set_01_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, print_small_size_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor target = constant(1.0, 3, 3, 1, 2, NHWC_);
+=======
+  nntrainer::Tensor target = constant(1.0, 3, 3, 1, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   std::stringstream ss, expected;
   ss << target;
@@ -3770,16 +5054,28 @@ TEST(nntrainer_Tensor, print_small_size_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, copy_and_reshape_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor A = constant(1.0f, 3, 4, 5, 6, NHWC_);
   nntrainer::Tensor B = A;
   nntrainer::Tensor C = A.clone();
 
   EXPECT_THROW(B.reshape(nntrainer::TensorDim(9, 9, 9, 9, NHWC_)),
+=======
+  nntrainer::Tensor A = constant(1.0f, 3, 4, 5, 6, NHWC_, FP32_);
+  nntrainer::Tensor B = A;
+  nntrainer::Tensor C = A.clone();
+
+  EXPECT_THROW(B.reshape(nntrainer::TensorDim(9, 9, 9, 9, NHWC_, FP32_)),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, copy_and_shares_variable_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor A = constant(1.0f, 3, 4, 5, 6, NHWC_);
+=======
+  nntrainer::Tensor A = constant(1.0f, 3, 4, 5, 6, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor B = A.clone();
   nntrainer::Tensor C = A;
 
@@ -3788,7 +5084,11 @@ TEST(nntrainer_Tensor, copy_and_shares_variable_nhwc_p) {
   EXPECT_EQ(A, C);
   EXPECT_NE(B, C);
 
+<<<<<<< HEAD
   C.reshape(nntrainer::TensorDim(3, 4, 6, 5, NHWC_));
+=======
+  C.reshape(nntrainer::TensorDim(3, 4, 6, 5, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_EQ(A.getDim(), B.getDim());
   EXPECT_NE(A.getDim(), C.getDim());
 }
@@ -3797,18 +5097,30 @@ TEST(nntrainer_Tensor, cat_01_nhwc_p) {
   {
     std::vector<nntrainer::Tensor> inputs;
     inputs.reserve(2);
+<<<<<<< HEAD
     inputs.emplace_back(ranged(2, 2, 1, 1, NHWC_));
     inputs.emplace_back(ranged(2, 2, 2, 1, NHWC_));
     float answer_data[] = {0, 1, 0, 1, 2, 3, 2, 3, 4, 5, 6, 7};
     nntrainer::Tensor answer(ml::train::TensorDim({2, 2, 3, 1}, NHWC_),
+=======
+    inputs.emplace_back(ranged(2, 2, 1, 1, NHWC_, FP32_));
+    inputs.emplace_back(ranged(2, 2, 2, 1, NHWC_, FP32_));
+    float answer_data[] = {0, 1, 0, 1, 2, 3, 2, 3, 4, 5, 6, 7};
+    nntrainer::Tensor answer(ml::train::TensorDim({2, 2, 3, 1}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     EXPECT_EQ(nntrainer::Tensor::cat(inputs, 2), answer);
   }
   {
     std::vector<nntrainer::Tensor> inputs;
     inputs.reserve(2);
+<<<<<<< HEAD
     inputs.emplace_back(ranged(3, 2, 4, 5, NHWC_));
     inputs.emplace_back(ranged(2, 2, 4, 5, NHWC_));
+=======
+    inputs.emplace_back(ranged(3, 2, 4, 5, NHWC_, FP32_));
+    inputs.emplace_back(ranged(2, 2, 4, 5, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,
       15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
@@ -3824,15 +5136,24 @@ TEST(nntrainer_Tensor, cat_01_nhwc_p) {
       45,  46,  47,  48,  49,  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,  78,  79};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({5, 2, 4, 5}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({5, 2, 4, 5}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     EXPECT_EQ(nntrainer::Tensor::cat(inputs, 0), answer);
   }
   {
     std::vector<nntrainer::Tensor> inputs;
     inputs.reserve(2);
+<<<<<<< HEAD
     inputs.emplace_back(ranged(3, 5, 3, 4, NHWC_));
     inputs.emplace_back(ranged(3, 5, 2, 4, NHWC_));
+=======
+    inputs.emplace_back(ranged(3, 5, 3, 4, NHWC_, FP32_));
+    inputs.emplace_back(ranged(3, 5, 2, 4, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,
       14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,
@@ -3856,31 +5177,50 @@ TEST(nntrainer_Tensor, cat_01_nhwc_p) {
       86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99,
       100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
       114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 5, 4}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 5, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     EXPECT_EQ(nntrainer::Tensor::cat(inputs, 2), answer);
   }
   {
     std::vector<nntrainer::Tensor> inputs;
     inputs.reserve(2);
+<<<<<<< HEAD
     inputs.emplace_back(ranged(3, 5, 2, 1, NHWC_));
     inputs.emplace_back(ranged(3, 5, 2, 2, NHWC_));
+=======
+    inputs.emplace_back(ranged(3, 5, 2, 1, NHWC_, FP32_));
+    inputs.emplace_back(ranged(3, 5, 2, 2, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  1,  2,  3,  4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  5,  6,  7,
       8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 10, 11, 12, 13, 14, 20,
       21, 22, 23, 24, 25, 26, 27, 28, 29, 15, 16, 17, 18, 19, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 20, 21, 22, 23, 24, 40, 41, 42, 43, 44, 45, 46,
       47, 48, 49, 25, 26, 27, 28, 29, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 2, 3}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 2, 3}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     EXPECT_EQ(nntrainer::Tensor::cat(inputs, 3), answer);
   }
   {
     std::vector<nntrainer::Tensor> inputs;
     inputs.reserve(3);
+<<<<<<< HEAD
     inputs.emplace_back(ranged(3, 1, 2, 4, NHWC_));
     inputs.emplace_back(ranged(3, 3, 2, 4, NHWC_));
     inputs.emplace_back(ranged(3, 2, 2, 4, NHWC_));
+=======
+    inputs.emplace_back(ranged(3, 1, 2, 4, NHWC_, FP32_));
+    inputs.emplace_back(ranged(3, 3, 2, 4, NHWC_, FP32_));
+    inputs.emplace_back(ranged(3, 2, 2, 4, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  0,  1,  2,  0,  1,  1,  3,  4,  5,  2,  3,  2,  6,  7,  8,  4,  5,
       3,  9,  10, 11, 6,  7,  4,  12, 13, 14, 8,  9,  5,  15, 16, 17, 10, 11,
@@ -3890,7 +5230,11 @@ TEST(nntrainer_Tensor, cat_01_nhwc_p) {
       15, 45, 46, 47, 30, 31, 16, 48, 49, 50, 32, 33, 17, 51, 52, 53, 34, 35,
       18, 54, 55, 56, 36, 37, 19, 57, 58, 59, 38, 39, 20, 60, 61, 62, 40, 41,
       21, 63, 64, 65, 42, 43, 22, 66, 67, 68, 44, 45, 23, 69, 70, 71, 46, 47};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 6, 2, 4}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 6, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     EXPECT_EQ(nntrainer::Tensor::cat(inputs, 1), answer);
   }
@@ -3900,8 +5244,13 @@ TEST(nntrainer_Tensor, cat_02_nhwc_n) {
   {
     std::vector<nntrainer::Tensor> inputs;
     inputs.reserve(2);
+<<<<<<< HEAD
     inputs.emplace_back(nntrainer::Tensor(2, 1, 1, 2, NHWC_));
     inputs.emplace_back(nntrainer::Tensor(2, 2, 1, 2, NHWC_));
+=======
+    inputs.emplace_back(nntrainer::Tensor(2, 1, 1, 2, NHWC_, FP32_));
+    inputs.emplace_back(nntrainer::Tensor(2, 2, 1, 2, NHWC_, FP32_));
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     EXPECT_THROW(nntrainer::Tensor::cat(inputs, 2), std::invalid_argument);
   }
 }
@@ -3935,7 +5284,11 @@ TEST(nntrainer_Tensor, TensorWrap_02_nhwc_n) {
 }
 
 TEST(nntrainer_Tensor, TensorPaddedValue_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::Tensor a = ranged(1, 1, 3, 3, NHWC_);
+=======
+  nntrainer::Tensor a = ranged(1, 1, 3, 3, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   float default_padded = -1;
 
   for (int i = 0; i < 5; ++i) {
@@ -3952,14 +5305,23 @@ TEST(nntrainer_Tensor, TensorPaddedValue_nhwc_p) {
 
 TEST(nntrainer_Tensor, zoneout_mask_01_nhwc_n) {
   const float zoneout_rate = 0.3f;
+<<<<<<< HEAD
   nntrainer::Tensor t(10, 10, 10, 10, NHWC_);
   nntrainer::Tensor opposite(20, 20, 20, 20, NHWC_);
+=======
+  nntrainer::Tensor t(10, 10, 10, 10, NHWC_, FP32_);
+  nntrainer::Tensor opposite(20, 20, 20, 20, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.zoneout_mask(opposite, zoneout_rate), std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, zoneout_mask_02_nhwc_p) {
   const float zoneout_rate = 0.3f;
+<<<<<<< HEAD
   nntrainer::Tensor t(10, 10, 10, 10, NHWC_);
+=======
+  nntrainer::Tensor t(10, 10, 10, 10, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor opposite = t.zoneout_mask(zoneout_rate);
   constexpr float epsilon = 1e-3;
 
@@ -3982,7 +5344,11 @@ TEST(nntrainer_Tensor, zoneout_mask_02_nhwc_p) {
 
 TEST(nntrainer_Tensor, zoneout_mask_03_nhwc_p) {
   const float zoneout_rate = 0.3f;
+<<<<<<< HEAD
   nntrainer::Tensor t(10, 10, 100, 100, NHWC_);
+=======
+  nntrainer::Tensor t(10, 10, 100, 100, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor opposite = t.zoneout_mask(zoneout_rate);
   constexpr float epsilon = 1e-3;
 
@@ -4033,7 +5399,11 @@ TEST(nntrainer_Tensor, zoneout_mask_03_nhwc_p) {
 
 TEST(nntrainer_Tensor, zoneout_mask_04_nhwc_n) {
   const float zoneout_rate = 0.3f;
+<<<<<<< HEAD
   nntrainer::Tensor t(10, 10, 100, 100, NHWC_);
+=======
+  nntrainer::Tensor t(10, 10, 100, 100, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   nntrainer::Tensor opposite = t.zoneout_mask(zoneout_rate);
   constexpr float epsilon = 1e-3;
 
@@ -4078,8 +5448,13 @@ TEST(nntrainer_Tensor, zoneout_mask_04_nhwc_n) {
 
 TEST(nntrainer_Tensor, split_01_nhwc_p) {
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(3);
     {
@@ -4087,7 +5462,11 @@ TEST(nntrainer_Tensor, split_01_nhwc_p) {
                              10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
                              20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
                              30, 31, 32, 33, 34, 35, 36, 37, 38, 39};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 5, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 5, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4095,7 +5474,11 @@ TEST(nntrainer_Tensor, split_01_nhwc_p) {
                              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, 78, 79};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 5, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 5, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4103,14 +5486,23 @@ TEST(nntrainer_Tensor, split_01_nhwc_p) {
                              90,  91,  92,  93,  94,  95,  96,  97,  98,  99,
                              100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
                              110, 111, 112, 113, 114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 5, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 5, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split(3, 0), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(2);
     {
@@ -4119,7 +5511,11 @@ TEST(nntrainer_Tensor, split_01_nhwc_p) {
                              44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
                              56, 57, 58, 59, 80, 81, 82, 83, 84, 85, 86, 87,
                              88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 5, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 5, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4129,14 +5525,23 @@ TEST(nntrainer_Tensor, split_01_nhwc_p) {
                              70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
                              100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
                              110, 111, 112, 113, 114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 5, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 5, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split(2, 2), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(2);
     {
@@ -4145,7 +5550,11 @@ TEST(nntrainer_Tensor, split_01_nhwc_p) {
         25, 26, 27, 28, 29, 40,  41,  42,  43,  44,  45,  46,  47,  48,  49,
         60, 61, 62, 63, 64, 65,  66,  67,  68,  69,  80,  81,  82,  83,  84,
         85, 86, 87, 88, 89, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 5, 2, 2}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 5, 2, 2}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4154,66 +5563,108 @@ TEST(nntrainer_Tensor, split_01_nhwc_p) {
         35, 36, 37, 38, 39, 50,  51,  52,  53,  54,  55,  56,  57,  58,  59,
         70, 71, 72, 73, 74, 75,  76,  77,  78,  79,  90,  91,  92,  93,  94,
         95, 96, 97, 98, 99, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 5, 2, 2}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 5, 2, 2}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split(2, 3), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(5);
     {
       float answer_data[] = {0,  5,  10, 15, 20,  25,  30,  35,
                              40, 45, 50, 55, 60,  65,  70,  75,
                              80, 85, 90, 95, 100, 105, 110, 115};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {1,  6,  11, 16, 21,  26,  31,  36,
                              41, 46, 51, 56, 61,  66,  71,  76,
                              81, 86, 91, 96, 101, 106, 111, 116};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {2,  7,  12, 17, 22,  27,  32,  37,
                              42, 47, 52, 57, 62,  67,  72,  77,
                              82, 87, 92, 97, 102, 107, 112, 117};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {3,  8,  13, 18, 23,  28,  33,  38,
                              43, 48, 53, 58, 63,  68,  73,  78,
                              83, 88, 93, 98, 103, 108, 113, 118};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {4,  9,  14, 19, 24,  29,  34,  39,
                              44, 49, 54, 59, 64,  69,  74,  79,
                              84, 89, 94, 99, 104, 109, 114, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split(5, 1), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(1, 6, 1, 4, NHWC_);
     nntrainer::Tensor t = ranged(1, 6, 1, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(1, 6, 1, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(1, 6, 1, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(2);
     {
       float answer_data[] = {0, 1, 2, 6, 7, 8, 12, 13, 14, 18, 19, 20};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 3, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 3, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {3, 4, 5, 9, 10, 11, 15, 16, 17, 21, 22, 23};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 3, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 3, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split(2, 1), answer);
@@ -4221,19 +5672,32 @@ TEST(nntrainer_Tensor, split_01_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, split_02_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t(1, 1, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor t(1, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.split(0, 0), std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, split_03_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t(3, 1, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor t(3, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.split(2, 0), std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, split_04_nhwc_p) {
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(2);
     {
@@ -4243,7 +5707,11 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
         32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
         48, 49, 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, 78, 79};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({2, 5, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({2, 5, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4251,14 +5719,23 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
                              90,  91,  92,  93,  94,  95,  96,  97,  98,  99,
                              100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
                              110, 111, 112, 113, 114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 5, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 5, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split({2, 1}, 0), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(2);
     {
@@ -4267,7 +5744,11 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
                              44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
                              56, 57, 58, 59, 80, 81, 82, 83, 84, 85, 86, 87,
                              88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 5, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 5, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4277,14 +5758,23 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
                              70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
                              100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
                              110, 111, 112, 113, 114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 5, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 5, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split({1, 1}, 2), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(2);
     {
@@ -4293,7 +5783,11 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
         25, 26, 27, 28, 29, 40,  41,  42,  43,  44,  45,  46,  47,  48,  49,
         60, 61, 62, 63, 64, 65,  66,  67,  68,  69,  80,  81,  82,  83,  84,
         85, 86, 87, 88, 89, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 5, 2, 2}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 5, 2, 2}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4302,21 +5796,34 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
         35, 36, 37, 38, 39, 50,  51,  52,  53,  54,  55,  56,  57,  58,  59,
         70, 71, 72, 73, 74, 75,  76,  77,  78,  79,  90,  91,  92,  93,  94,
         95, 96, 97, 98, 99, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 5, 2, 2}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 5, 2, 2}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split({2, 2}, 3), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(3);
     {
       float answer_data[] = {0,  5,  10, 15, 20,  25,  30,  35,
                              40, 45, 50, 55, 60,  65,  70,  75,
                              80, 85, 90, 95, 100, 105, 110, 115};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4326,21 +5833,34 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
         51,  52,  53,  56,  57,  58,  61,  62,  63,  66,  67,  68, 71, 72, 73,
         76,  77,  78,  81,  82,  83,  86,  87,  88,  91,  92,  93, 96, 97, 98,
         101, 102, 103, 106, 107, 108, 111, 112, 113, 116, 117, 118};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 3, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 3, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {4,  9,  14, 19, 24,  29,  34,  39,
                              44, 49, 54, 59, 64,  69,  74,  79,
                              84, 89, 94, 99, 104, 109, 114, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split({1, 3, 1}, 1), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(3);
     {
@@ -4348,7 +5868,11 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
         0,  1,  5,  6,  10, 11, 15, 16, 20,  21,  25,  26,  30,  31,  35,  36,
         40, 41, 45, 46, 50, 51, 55, 56, 60,  61,  65,  66,  70,  71,  75,  76,
         80, 81, 85, 86, 90, 91, 95, 96, 100, 101, 105, 106, 110, 111, 115, 116};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 2, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 2, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4356,21 +5880,34 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
         2,  3,  7,  8,  12, 13, 17, 18, 22,  23,  27,  28,  32,  33,  37,  38,
         42, 43, 47, 48, 52, 53, 57, 58, 62,  63,  67,  68,  72,  73,  77,  78,
         82, 83, 87, 88, 92, 93, 97, 98, 102, 103, 107, 108, 112, 113, 117, 118};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 2, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 2, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {4,  9,  14, 19, 24,  29,  34,  39,
                              44, 49, 54, 59, 64,  69,  74,  79,
                              84, 89, 94, 99, 104, 109, 114, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 1, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split({2, 2, 1}, 1), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(2);
     {
@@ -4378,7 +5915,11 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
         0,  1,  5,  6,  10, 11, 15, 16, 20,  21,  25,  26,  30,  31,  35,  36,
         40, 41, 45, 46, 50, 51, 55, 56, 60,  61,  65,  66,  70,  71,  75,  76,
         80, 81, 85, 86, 90, 91, 95, 96, 100, 101, 105, 106, 110, 111, 115, 116};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 2, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 2, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
@@ -4388,29 +5929,50 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
         52,  53,  54,  57,  58,  59,  62,  63,  64,  67,  68,  69, 72, 73, 74,
         77,  78,  79,  82,  83,  84,  87,  88,  89,  92,  93,  94, 97, 98, 99,
         102, 103, 104, 107, 108, 109, 112, 113, 114, 117, 118, 119};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({3, 3, 2, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({3, 3, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split({2, 3}, 1), answer);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(1, 6, 1, 4, NHWC_);
     nntrainer::Tensor t = ranged(1, 6, 1, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(1, 6, 1, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(1, 6, 1, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     std::vector<nntrainer::Tensor> answer;
     answer.reserve(3);
     {
       float answer_data[] = {0, 6, 12, 18};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 1, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 1, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {1, 2, 3, 7, 8, 9, 13, 14, 15, 19, 20, 21};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 3, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 3, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     {
       float answer_data[] = {4, 5, 10, 11, 16, 17, 22, 23};
+<<<<<<< HEAD
       answer.emplace_back(ml::train::TensorDim({1, 2, 1, 4}, NHWC_),
+=======
+      answer.emplace_back(ml::train::TensorDim({1, 2, 1, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                           answer_data);
     }
     EXPECT_EQ(t.split({1, 3, 2}, 1), answer);
@@ -4418,27 +5980,48 @@ TEST(nntrainer_Tensor, split_04_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, split_05_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t(3, 1, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor t(3, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.split({1, 1}, 0), std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, split_06_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t(3, 1, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor t(3, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.split({2, 0, 1}, 0), std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, split_07_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor t(3, 1, 1, 1, NHWC_);
+=======
+  nntrainer::Tensor t(3, 1, 1, 1, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
   EXPECT_THROW(t.split({}, 0), std::invalid_argument);
 }
 
 TEST(nntrainer_Tensor, transpose_nhwc_p) {
+<<<<<<< HEAD
   nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
 
   /// plain transpose
   {
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+  nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+
+  /// plain transpose
+  {
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,
       14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,
@@ -4449,14 +6032,23 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,
       98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
       112, 113, 114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 2, 4}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor m = t.transpose("0:1:2");
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   5,   10,  15,  1,   6,   11,  16,  2,   7,   12,  17,  3,   8,
       13,  18,  4,   9,   14,  19,  20,  25,  30,  35,  21,  26,  31,  36,
@@ -4467,14 +6059,23 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       81,  86,  91,  96,  82,  87,  92,  97,  83,  88,  93,  98,  84,  89,
       94,  99,  100, 105, 110, 115, 101, 106, 111, 116, 102, 107, 112, 117,
       103, 108, 113, 118, 104, 109, 114, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 4, 2, 5}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 4, 2, 5}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor m = t.transpose("2:1:0");
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   4,   20,  21,  22,  23,  24,  5,   6,   7,   8,
       9,   25,  26,  27,  28,  29,  10,  11,  12,  13,  14,  30,  31,  32,
@@ -4485,14 +6086,23 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       84,  100, 101, 102, 103, 104, 85,  86,  87,  88,  89,  105, 106, 107,
       108, 109, 90,  91,  92,  93,  94,  110, 111, 112, 113, 114, 95,  96,
       97,  98,  99,  115, 116, 117, 118, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 4, 2}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 4, 2}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor m = t.transpose("0:2:1");
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  20,  1,  21,  2,  22,  3,  23,  4,  24,  5,  25,  6,  26,  7,  27,
       8,  28,  9,  29,  10, 30,  11, 31,  12, 32,  13, 33,  14, 34,  15, 35,
@@ -4502,14 +6112,23 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       80, 100, 81, 101, 82, 102, 83, 103, 84, 104, 85, 105, 86, 106, 87, 107,
       88, 108, 89, 109, 90, 110, 91, 111, 92, 112, 93, 113, 94, 114, 95, 115,
       96, 116, 97, 117, 98, 118, 99, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 2, 4, 5}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 2, 4, 5}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor m = t.transpose("1:2:0");
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  5,  10,  15,  20,  25,  30,  35, 1,  6,   11,  16,  21,  26,  31,
       36, 2,  7,   12,  17,  22,  27,  32, 37, 3,   8,   13,  18,  23,  28,
@@ -4519,14 +6138,23 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       59, 64, 69,  74,  79,  80,  85,  90, 95, 100, 105, 110, 115, 81,  86,
       91, 96, 101, 106, 111, 116, 82,  87, 92, 97,  102, 107, 112, 117, 83,
       88, 93, 98,  103, 108, 113, 118, 84, 89, 94,  99,  104, 109, 114, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 4, 5, 2}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 4, 5, 2}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor m = t.transpose("2:0:1");
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  20,  5,  25,  10, 30,  15, 35,  1,  21,  6,  26,  11, 31,  16, 36,
       2,  22,  7,  27,  12, 32,  17, 37,  3,  23,  8,  28,  13, 33,  18, 38,
@@ -4536,7 +6164,11 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       80, 100, 85, 105, 90, 110, 95, 115, 81, 101, 86, 106, 91, 111, 96, 116,
       82, 102, 87, 107, 92, 112, 97, 117, 83, 103, 88, 108, 93, 113, 98, 118,
       84, 104, 89, 109, 94, 114, 99, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 2, 5, 4}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 2, 5, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     nntrainer::Tensor m = t.transpose("1:0:2");
     EXPECT_EQ(answer, m);
@@ -4544,9 +6176,15 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
 
   /// outplace transpose
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor m = ranged(3, 5, 2, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 5, 2, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,
       14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,
@@ -4557,15 +6195,25 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,
       98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
       112, 113, 114, 115, 116, 117, 118, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 2, 4}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 2, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     t.transpose("0:1:2", m);
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor m = ranged(3, 4, 2, 5, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 4, 2, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   5,   10,  15,  1,   6,   11,  16,  2,   7,   12,  17,  3,   8,
       13,  18,  4,   9,   14,  19,  20,  25,  30,  35,  21,  26,  31,  36,
@@ -4576,15 +6224,25 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       81,  86,  91,  96,  82,  87,  92,  97,  83,  88,  93,  98,  84,  89,
       94,  99,  100, 105, 110, 115, 101, 106, 111, 116, 102, 107, 112, 117,
       103, 108, 113, 118, 104, 109, 114, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 4, 2, 5}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 4, 2, 5}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     t.transpose("2:1:0", m);
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor m = ranged(3, 5, 4, 2, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 5, 4, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,   1,   2,   3,   4,   20,  21,  22,  23,  24,  5,   6,   7,   8,
       9,   25,  26,  27,  28,  29,  10,  11,  12,  13,  14,  30,  31,  32,
@@ -4595,15 +6253,25 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       84,  100, 101, 102, 103, 104, 85,  86,  87,  88,  89,  105, 106, 107,
       108, 109, 90,  91,  92,  93,  94,  110, 111, 112, 113, 114, 95,  96,
       97,  98,  99,  115, 116, 117, 118, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 4, 2}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 5, 4, 2}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     t.transpose("0:2:1", m);
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor m = ranged(3, 2, 4, 5, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 2, 4, 5, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  20,  1,  21,  2,  22,  3,  23,  4,  24,  5,  25,  6,  26,  7,  27,
       8,  28,  9,  29,  10, 30,  11, 31,  12, 32,  13, 33,  14, 34,  15, 35,
@@ -4613,15 +6281,25 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       80, 100, 81, 101, 82, 102, 83, 103, 84, 104, 85, 105, 86, 106, 87, 107,
       88, 108, 89, 109, 90, 110, 91, 111, 92, 112, 93, 113, 94, 114, 95, 115,
       96, 116, 97, 117, 98, 118, 99, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 2, 4, 5}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 2, 4, 5}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     t.transpose("1:2:0", m);
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor m = ranged(3, 4, 5, 2, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 4, 5, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  5,  10,  15,  20,  25,  30,  35, 1,  6,   11,  16,  21,  26,  31,
       36, 2,  7,   12,  17,  22,  27,  32, 37, 3,   8,   13,  18,  23,  28,
@@ -4631,15 +6309,25 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       59, 64, 69,  74,  79,  80,  85,  90, 95, 100, 105, 110, 115, 81,  86,
       91, 96, 101, 106, 111, 116, 82,  87, 92, 97,  102, 107, 112, 117, 83,
       88, 93, 98,  103, 108, 113, 118, 84, 89, 94,  99,  104, 109, 114, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 4, 5, 2}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 4, 5, 2}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     t.transpose("2:0:1", m);
     EXPECT_EQ(answer, m);
   }
   {
+<<<<<<< HEAD
     nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_);
     nntrainer::Tensor m = ranged(3, 2, 5, 4, NHWC_);
+=======
+    nntrainer::TensorDim ref_dim(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor t = ranged(3, 5, 2, 4, NHWC_, FP32_);
+    nntrainer::Tensor m = ranged(3, 2, 5, 4, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
     float answer_data[] = {
       0,  20,  5,  25,  10, 30,  15, 35,  1,  21,  6,  26,  11, 31,  16, 36,
       2,  22,  7,  27,  12, 32,  17, 37,  3,  23,  8,  28,  13, 33,  18, 38,
@@ -4649,7 +6337,11 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
       80, 100, 85, 105, 90, 110, 95, 115, 81, 101, 86, 106, 91, 111, 96, 116,
       82, 102, 87, 107, 92, 112, 97, 117, 83, 103, 88, 108, 93, 113, 98, 118,
       84, 104, 89, 109, 94, 114, 99, 119};
+<<<<<<< HEAD
     nntrainer::Tensor answer(ml::train::TensorDim({3, 2, 5, 4}, NHWC_),
+=======
+    nntrainer::Tensor answer(ml::train::TensorDim({3, 2, 5, 4}, NHWC_, FP32_),
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
                              answer_data);
     t.transpose("1:0:2", m);
     EXPECT_EQ(answer, m);
@@ -4657,8 +6349,13 @@ TEST(nntrainer_Tensor, transpose_nhwc_p) {
 }
 
 TEST(nntrainer_Tensor, tranpose_dimension_not_match_nhwc_n) {
+<<<<<<< HEAD
   nntrainer::Tensor a(3, 5, 2, 4, NHWC_);
   nntrainer::Tensor b(3, 3, 1, 2, NHWC_);
+=======
+  nntrainer::Tensor a(3, 5, 2, 4, NHWC_, FP32_);
+  nntrainer::Tensor b(3, 3, 1, 2, NHWC_, FP32_);
+>>>>>>> 4bea9510... [ Tensor ] Support NHWC for dot, add/multiply_strided and other ops
 
   EXPECT_THROW(a.transpose("0:1:2", b), std::invalid_argument);
 }