--- /dev/null
+/*
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd. 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 "ConstantInitializer.h"
+
+#include <arm_compute/core/Coordinates.h>
+
+#include "backend/interface/operand/IObject.h"
+#include "backend/interface/IConfig.h"
+#include "backend/acl_cl/kernel/View.h"
+#include "backend/BackendManager.h"
+#include "internal/nnapi/kernel/Reader.h"
+#include "internal/nnapi/kernel/View.h"
+#include "util/kernel/IndexIterator.h"
+#include "graph/operation/FullyConnected.h"
+#include "logging.h"
+
+namespace neurun
+{
+namespace codegen
+{
+
+ConstantInitializer::ConstantInitializer(const graph::Graph &graph, Plan &plan)
+ : _graph{graph}, _plan{plan}
+{
+}
+
+void ConstantInitializer::operator()()
+{
+ // Fill operand data
+ _plan.operands().iterate([&](int ind, neurun::backend::operand::IObject &obj) {
+ neurun::graph::operand::Index index(ind);
+ const auto &model_obj = _graph.operands().at(index);
+
+ // For only CONSTANTS
+ if (model_obj.getUsage() != neurun::graph::operand::OperandUsage::CONSTANT)
+ return;
+
+ // Only float32 is supported
+ auto type = model_obj.typeInfo().type();
+ if (type != ::neurun::graph::operand::DataType::TENSOR_FLOAT32)
+ throw std::runtime_error{"Unsupported data type. Only TENSOR_FLOAT32 is supported."};
+
+ VERBOSE(FillOperandData) << "Fill data for operand " << ind << std::endl;
+
+ auto layout =
+ model_obj.lower_info()->def_backends().getOnlyElement()->config()->getOperandLayout();
+ const auto shape = model_obj.shape();
+ auto base = model_obj.data().base();
+ auto size = model_obj.data().size();
+
+ obj.access([&](::arm_compute::ITensor &tensor) {
+ switch (shape.rank())
+ {
+ case 1:
+ {
+ auto vec_size = shape.asVector();
+ for (int32_t n = 0; n < vec_size; ++n)
+ {
+ const ::arm_compute::Coordinates coordinate{n};
+
+ float *into = reinterpret_cast<float *>(tensor.ptr_to_element(coordinate));
+
+ const float *from = reinterpret_cast<const float *>(base) + n;
+ const auto value = *from;
+
+ *into = value;
+ }
+ break;
+ }
+ case 2:
+ {
+ // NOTE This is a WORKAROUND which supports FullyConnected weight only
+ // For FullyConnected, we must know the IFM shape to deduce 2D weight shape from 4D
+ // IFM.
+ // This is because of NHWC/NCHW layout, the order of mapping will be different.
+ // TODO Support general case - explicitly insert Reshape op for IFM as 2D
+
+ // Find corresponding FullyConnected IFM
+ auto operation_index = _graph.operands().at(index).getUses().list().front();
+ auto operation = &_graph.operations().at(operation_index);
+ auto fc_operation =
+ dynamic_cast<const neurun::graph::operation::FullyConnected::Node *>(operation);
+
+ if (fc_operation == nullptr)
+ break;
+
+ auto ifm_index =
+ fc_operation->getInputs().at(neurun::graph::operation::FullyConnected::Input::INPUT);
+ const auto &ifm = _graph.operands().at(ifm_index);
+ const auto ifm_shape = ifm.shape().asFeature();
+ const auto num_output = shape.dim(0);
+
+ const ::nnfw::util::kernel::Shape ker_shape{num_output, ifm_shape.C, ifm_shape.H,
+ ifm_shape.W};
+ const ::internal::nnapi::kernel::Reader<float> from{ker_shape, base, size};
+
+ if (layout == neurun::graph::operand::Layout::NHWC)
+ {
+ ::nnfw::util::kernel::iterate(ker_shape)
+ << [&](uint32_t nth, uint32_t ch, uint32_t row, uint32_t col) {
+ const auto value = from.at(nth, ch, row, col);
+
+ uint32_t offset = 0;
+
+ // NNAPI uses NHWC ordering
+ offset += nth * ifm_shape.H * ifm_shape.W * ifm_shape.C;
+ offset += row * ifm_shape.W * ifm_shape.C;
+ offset += col * ifm_shape.C;
+ offset += ch;
+
+ const ::arm_compute::Coordinates coordinate{offset};
+
+ auto into = reinterpret_cast<float *>(tensor.ptr_to_element(coordinate));
+
+ *into = value;
+ };
+ }
+ else
+ {
+ assert(layout == neurun::graph::operand::Layout::NCHW);
+
+ ::nnfw::util::kernel::iterate(ker_shape)
+ << [&](uint32_t nth, uint32_t ch, uint32_t row, uint32_t col) {
+ const auto value = from.at(nth, ch, row, col);
+
+ uint32_t offset = 0;
+
+ // 'NCHW' ordering
+ offset += nth * ifm_shape.C * ifm_shape.H * ifm_shape.W;
+ offset += ch * ifm_shape.H * ifm_shape.W;
+ offset += row * ifm_shape.W;
+ offset += col;
+
+ const ::arm_compute::Coordinates coordinate{offset};
+
+ auto into = reinterpret_cast<float *>(tensor.ptr_to_element(coordinate));
+
+ *into = value;
+ };
+ }
+
+ break;
+ }
+ case 4:
+ {
+ auto ker_shape = shape.asKernel();
+ auto from = ::internal::nnapi::kernel::Reader<float>{ker_shape, base, size};
+
+ if (layout == neurun::graph::operand::Layout::NHWC)
+ {
+ auto into = ::internal::nnapi::kernel::View<float>{&tensor};
+
+ ::nnfw::util::kernel::iterate(ker_shape)
+ << [&](uint32_t nth, uint32_t ch, uint32_t row, uint32_t col) {
+ const auto value = from.at(nth, ch, row, col);
+ into.at(nth, row, col, ch) = value;
+ };
+ }
+ else
+ {
+ assert(layout == neurun::graph::operand::Layout::NCHW);
+
+ auto into = ::internal::arm_compute::kernel::View<float>{&tensor};
+
+ ::nnfw::util::kernel::iterate(ker_shape)
+ << [&](uint32_t nth, uint32_t ch, uint32_t row, uint32_t col) {
+ const auto value = from.at(nth, ch, row, col);
+ into.at(nth, ch, row, col) = value;
+ };
+ }
+ break;
+ }
+ default:
+ throw std::runtime_error{"Not yet supported"};
+ }
+ });
+ });
+}
+
+} // namespace codegen
+} // namespace neurun
projects / platform / core / ml / nnfw.git / commitdiff