add norm_op

src/operators/kernel/arm/norm_kernel.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#ifdef NORM_OP
+
+#include "operators/kernel/norm_kernel.h"
+#include "operators/kernel/central-arm-func/norm_arm_func.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+template <>
+bool NormKernel<CPU, float>::Init(NormParam<CPU> *param) {
+  return true;
+}
+
+template <>
+void NormKernel<CPU, float>::Compute(const NormParam<CPU> &param) {
+  NormCompute<float>(param);
+}
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+#endif

src/operators/kernel/central-arm-func/norm_arm_func.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#ifdef NORM_OP
+
+#pragma once
+
+#include <cmath>
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+inline void GetDims(const framework::DDim &dim, int axis, int *pre, int *n,
+                    int *post) {
+  *pre = 1;
+  *post = 1;
+  *n = dim[axis];
+  for (int i = 0; i < axis; ++i) {
+    (*pre) *= dim[i];
+  }
+  for (int i = axis + 1; i < dim.size(); ++i) {
+    (*post) *= dim[i];
+  }
+}
+
+template <typename P>
+void NormCompute(const NormParam<CPU> &param) {
+  const float epsilon = param.Epsilon();
+  int axis = param.Axis();
+
+  const framework::Tensor *input = param.InputX();
+  framework::Tensor square;
+  framework::Tensor *norm = param.OutputNorm();
+  framework::Tensor *out = param.Out();
+
+  auto x_dims = input->dims();
+  if (axis < 0) {
+    axis += x_dims.size();
+  }
+
+  int pre, n, post;
+  GetDims(x_dims, axis, &pre, &n, &post);
+
+  framework::DDim shape = {pre, n, post};
+  framework::DDim norm_shape = {pre, post};
+  square.Resize(shape);
+
+  const float *input_ptr = input->data<float>();
+  float *square_ptr = square.mutable_data<float>();
+  float *norm_ptr = norm->mutable_data<float>();
+  float *out_ptr = out->mutable_data<float>();
+
+  const float *in_tmp = input_ptr;
+  float *square_tmp = square_ptr;
+  for (int i = 0; i < input->numel(); ++i) {
+    float element = *in_tmp;
+    *square_tmp = element * element;
+    square_tmp++;
+    in_tmp++;
+  }
+
+  //  const float *norm_tmp = norm_ptr;
+  //  for (int i = 0; i < norm->numel(); ++i) {
+  //    *norm_tmp = 0;
+  //    norm_tmp++;
+  //  }
+
+  square_tmp = square_ptr;
+  float *norm_tmp = norm_ptr;
+  for (int i = 0; i < pre; ++i) {
+    for (int j = 0; j < post; ++j) {
+      for (int k = 0; k < n; ++k) {
+        if (k == 0) {
+          *norm_tmp = *square_tmp;
+        } else {
+          *norm_tmp += *(square_tmp + k * post);
+        }
+      }
+      float sum = *norm_tmp + epsilon;
+      *norm_tmp = sqrtf(sum);
+      norm_tmp++;
+      square_tmp++;
+    }
+  }
+
+  in_tmp = input_ptr;
+  norm_tmp = norm_ptr;
+  float *out_tmp = out_ptr;
+  for (int i = 0; i < pre; ++i) {
+    for (int k = 0; k < n; ++k) {
+      for (int j = 0; j < post; ++j) {
+        *out_tmp = *in_tmp / *norm_tmp;
+        in_tmp++;
+        norm_tmp++;
+        out_tmp++;
+      }
+      out_tmp = out_ptr + i * post;
+    }
+  }
+
+  delete (square_ptr);
+}
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+#endif

src/operators/kernel/norm_kernel.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#ifdef NORM_OP
+
+#pragma once
+
+#include "framework/operator.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+template <typename DeviceType, typename T>
+class NormKernel
+    : public framework::OpKernelBase<DeviceType, NormParam<DeviceType>> {
+ public:
+  void Compute(const NormParam<DeviceType> &param);
+  bool Init(NormParam<DeviceType> *param);
+};
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+#endif

src/operators/math/conv1x1.cpp

+//
+// Created by Zhao,Jiaying(MMS) on 2019/1/10.
+//
+

src/operators/math/conv1x1.h

+//
+// Created by Zhao,Jiaying(MMS) on 2019/1/10.
+//
+
+#ifndef PADDLE_MOBILE_CONV1X1_H
+#define PADDLE_MOBILE_CONV1X1_H
+
+#endif //PADDLE_MOBILE_CONV1X1_H

src/operators/norm_op.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#ifdef NORM_OP
+
+#include "operators/norm_op.h"
+#include "framework/op_proto_maker.h"
+#include "framework/op_registry.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+template <typename Dtype, typename T>
+void NormOp<Dtype, T>::InferShape() const {
+  auto x_dims = this->param_.InputX()->dims();
+  this->param_.Out()->Resize(x_dims);
+
+  int axis = this->param_.Axis();
+  if (axis < 0) {
+    axis += x_dims.size();
+  }
+  x_dims[axis] = 1;
+  this->param_.OutputNorm()->Resize(x_dims);
+}
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+namespace ops = paddle_mobile::operators;
+#ifdef PADDLE_MOBILE_CPU
+REGISTER_OPERATOR_CPU(norm, ops::NormOp);
+#endif
+#ifdef PADDLE_MOBILE_MALI_GPU
+REGISTER_OPERATOR_MALI_GPU(norm, ops::NormOp);
+#endif
+#ifdef PADDLE_MOBILE_FPGA
+#endif
+
+#ifdef PADDLE_MOBILE_CL
+REGISTER_OPERATOR_CL(norm, ops::NormOp);
+#endif
+
+#endif

src/operators/norm_op.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#ifdef NORM_OP
+
+#pragma once
+
+#include <string>
+#include "framework/operator.h"
+#include "operators/kernel/norm_kernel.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+using std::string;
+template <typename DeviceType, typename T>
+class NormOp
+    : public framework::OperatorWithKernel<DeviceType, NormParam<DeviceType>,
+                                           NormKernel<DeviceType, T>> {
+ public:
+  NormOp(const string &type, const VariableNameMap &inputs,
+         const VariableNameMap &outputs, const framework::AttributeMap &attrs,
+         std::shared_ptr<framework::Scope> scope)
+      : framework::OperatorWithKernel<DeviceType, NormParam<DeviceType>,
+                                      NormKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
+
+  void InferShape() const override;
+
+ protected:
+};
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+#endif

src/operators/op_param.h

@@ -280,6 +280,11 @@ class OpParam {
     return GetVarValue<T>("OutputBox", outputs, scope);
   }
 
+  template <typename T>
+  static T *OutputNormFrom(const VariableNameMap &outputs, const Scope &scope) {
+    return GetVarValue<T>("Norm", outputs, scope);
+  }
+
   template <typename T>
   static T *OutputVariancesFrom(const VariableNameMap &outputs,
                                 const Scope &scope) {
@@ -733,6 +738,41 @@ class LrnParam : public OpParam {
 };
 #endif
 
+#ifdef NORM_OP
+template <typename Dtype>
+class NormParam : OpParam {
+  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
+  typedef typename DtypeTensorTrait<Dtype>::rtype RType;
+
+ public:
+  NormParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
+            const AttributeMap &attrs, const Scope &scope) {
+    input_x_ = InputXFrom<GType>(inputs, scope);
+    out_ = OutFrom<GType>(outputs, scope);
+    output_norm_ = OutputNormFrom<GType>(outputs, scope);
+    epsilon_ = GetAttr<float>("epsilon", attrs);
+    axis_ = GetAttr<int>("axis", attrs);
+  }
+
+  const RType *InputX() const { return input_x_; }
+
+  RType *Out() const { return out_; }
+
+  RType *OutputNorm() const { return output_norm_; }
+
+  const float &Epsilon() const { return epsilon_; }
+
+  const int &Axis() const { return axis_; }
+
+ private:
+  RType *input_x_;
+  RType *out_;
+  RType *output_norm_;
+  float epsilon_;
+  int axis_;
+};
+#endif
+
 #ifdef BATCHNORM_OP
 template <typename Dtype>
 class BatchNormParam : OpParam {

test/CMakeLists.txt

@@ -394,4 +394,9 @@ if (NOT FOUND_MATCH)
 
     ADD_EXECUTABLE(test-sequence-softmax operators/test_sequence_softmax_op.cpp test_helper.h test_include.h)
     target_link_libraries(test-sequence-softmax paddle-mobile)
+
+    # gen test
+    ADD_EXECUTABLE(test-vgg16ssd net/test_vgg16ssd.cpp test_helper.h test_include.h)
+    target_link_libraries(test-vgg16ssd paddle-mobile)
+
 endif ()

test/net/test_vgg16ssd.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include <iostream>
+#include "../test_helper.h"
+#include "../test_include.h"
+
+int main() {
+  paddle_mobile::PaddleMobile<paddle_mobile::CPU> paddle_mobile;
+  paddle_mobile.SetThreadNum(1);
+  auto time1 = paddle_mobile::time();
+
+  auto isok =
+      paddle_mobile.Load(std::string(g_vgg16_ssd_combined) + "/model",
+                         std::string(g_vgg16_ssd_combined) + "/params", false);
+  if (isok) {
+    auto time2 = paddle_mobile::time();
+    std::cout << "load cost :" << paddle_mobile::time_diff(time1, time1) << "ms"
+              << std::endl;
+
+    std::vector<int64_t> dims{1, 3, 300, 300};
+    Tensor input_tensor;
+    SetupTensor<float>(&input_tensor, {1, 3, 300, 300}, static_cast<float>(0),
+                       static_cast<float>(1));
+
+    std::vector<float> input(input_tensor.data<float>(),
+                             input_tensor.data<float>() + input_tensor.numel());
+
+    auto vec_result = paddle_mobile.Predict(input, dims);
+
+    DLOG << vec_result;
+  }
+
+  return 0;
+}

test/test_helper.h

@@ -50,6 +50,7 @@ static const char *g_yolo = "../models/yolo";
 static const char *g_yolo_combined = "../models/yolo_combined";
 static const char *g_yolo_mul = "../models/d";
 static const char *g_fluid_fssd_new = "../models/fluid_fssd_new";
+static const char *g_vgg16_ssd_combined = "../models/vgg16_ssd_combined";
 static const char *g_test_image_1x3x224x224 =
     "../images/test_image_1x3x224x224_float";
 static const char *g_test_image_1x3x224x224_banana =

tools/ios-cmake/ios.toolchain.cmake

@@ -146,6 +146,7 @@ if (NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT)
 endif (NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT)
 set (CMAKE_IOS_DEVELOPER_ROOT ${CMAKE_IOS_DEVELOPER_ROOT} CACHE PATH "Location of iOS Platform")
 
+set(CMAKE_IOS_SDK_ROOT "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk")
 # Find and use the most recent iOS sdk unless specified manually with CMAKE_IOS_SDK_ROOT
 if (NOT DEFINED CMAKE_IOS_SDK_ROOT)
   file (GLOB _CMAKE_IOS_SDKS "${CMAKE_IOS_DEVELOPER_ROOT}/SDKs/*")

tools/op.cmake

@@ -215,6 +215,7 @@ endif()
 
 if(NOT FOUND_MATCH)
   message("--default--")
+  set(NORM_OP ON)
   set(BATCHNORM_OP ON)
   set(CONV_TRANSPOSE_OP ON)
   set(BOXCODER_OP ON)
@@ -302,6 +303,9 @@ endif()
   # option(TRANSPOSE2_OP "" ON)
 # endif ()
 
+if (NORM_OP)
+  add_definitions(-DNORM_OP)
+endif()
 if (BATCHNORM_OP)
   add_definitions(-DBATCHNORM_OP)
 endif()