#include <arm_compute/runtime/CL/functions/CLActivationLayer.h>
#include <arm_compute/runtime/CL/functions/CLSoftmaxLayer.h>
#include <arm_compute/runtime/CL/functions/CLArithmeticAddition.h>
+#include <arm_compute/runtime/CL/functions/CLArithmeticSubtraction.h>
#include <arm_compute/runtime/misc/functions/GenericReshapeLayer.h>
#include <arm_compute/runtime/CL/functions/CLDepthwiseConvolutionLayer.h>
#include <arm_compute/runtime/misc/functions/GenericFullyConnectedLayer.h>
});
}
+void StageGenerator::visit(const model::operation::SubNode &node)
+{
+ const auto output_index{node.getOutputs().at(0)};
+ const auto lhs_index{node.getInputs().at(model::operation::SubNode::Input::LHS)};
+ const auto rhs_index{node.getInputs().at(model::operation::SubNode::Input::RHS)};
+ const auto activation_index{node.param().activation_index};
+
+ if (!(_ctx.at(lhs_index).shape() == _ctx.at(rhs_index).shape()))
+ {
+ const auto broadcast_rank =
+ std::max(_ctx.at(lhs_index).shape().rank(), _ctx.at(rhs_index).shape().rank());
+
+ // TODO remove const_cast later. For example, _ctx may need to be a non const variable or
+ // a node to extend shape may be inserted in front of this operation
+ const_cast<::neurun::model::operand::Shape &>(_ctx.at(lhs_index).shape())
+ .extendRank(broadcast_rank);
+ const_cast<::neurun::model::operand::Shape &>(_ctx.at(rhs_index).shape())
+ .extendRank(broadcast_rank);
+ }
+
+ struct Param
+ {
+ model::operand::Index ofm_index;
+ model::operand::Index lhs_index;
+ model::operand::Index rhs_index;
+
+ FuseCode activation;
+ };
+
+ Param param;
+
+ param.ofm_index = output_index;
+ param.lhs_index = lhs_index;
+ param.rhs_index = rhs_index;
+
+ param.activation = static_cast<FuseCode>(_ctx.at(activation_index).asScalar<int32_t>());
+
+ auto tensors = _tensor_builder;
+
+ returnStage([tensors, param](IExecutionBuilder &builder) {
+ auto ofm_alloc = tensors->at(param.ofm_index).get();
+ auto lhs_alloc = tensors->at(param.lhs_index).get();
+ auto rhs_alloc = tensors->at(param.rhs_index).get();
+
+ std::unique_ptr<::arm_compute::IFunction> fn;
+
+ auto l = make_layer<::arm_compute::CLArithmeticSubtraction>();
+
+ l->configure(lhs_alloc->handle(), rhs_alloc->handle(), ofm_alloc->handle(),
+ arm_compute::ConvertPolicy::SATURATE);
+
+ fn = std::move(l);
+
+ auto acl_fn = make_cl_function(std::move(fn));
+
+ builder.append(std::move(acl_fn));
+
+ ActivationBuilder{builder}.append(param.activation, ofm_alloc->handle());
+ });
+}
+
} // namespace acl_cl
} // namespace backend
} // namespace neurun
void StageGenerator::visit(const model::operation::AddNode &) { throw std::runtime_error("NYI"); }
+void StageGenerator::visit(const model::operation::SubNode &) { throw std::runtime_error("NYI"); }
+
} // namespace neurun
} // namespace backend
} // namespace cpu
// DO NOTHING
}
+void OperationValidator::visit(const model::operation::SubNode &)
+{
+ // DO NOTHING
+}
+
} // namespace compiler
} // namespace neurun
return new operation::AddNode{inputs, outputs, param};
};
+ _map[ANEURALNETWORKS_SUB] = [](const OperationFactory::Param &init_param) {
+ assert(init_param.input_count == 3);
+ assert(init_param.output_count == 1);
+
+ // Each input should be interpreted as follows:
+ //
+ // 0 -> Lefthand side operand
+ // 1 -> Righthand side operand
+
+ operand::IndexSet inputs{init_param.inputs[0], init_param.inputs[1]};
+ operand::IndexSet outputs{init_param.outputs[0]};
+
+ operation::SubNode::Param param;
+
+ param.activation_index = operand::Index{init_param.inputs[2]};
+
+ return new operation::SubNode{inputs, outputs, param};
+ };
+
_map[ANEURALNETWORKS_STRIDED_SLICE] = [](const OperationFactory::Param &init_param) {
assert(init_param.input_count == 7 && init_param.output_count == 1);
switch (type)
{
case ANEURALNETWORKS_ADD:
+ case ANEURALNETWORKS_SUB:
case ANEURALNETWORKS_CONV_2D:
case ANEURALNETWORKS_MUL:
case ANEURALNETWORKS_TANH:
#include "SoftmaxNode.h"
#include "PermuteNode.h"
#include "AddNode.h"
+#include "SubNode.h"
#include "DepthwiseConv2DNode.h"
#include "StridedSliceNode.h"
#include "MulNode.h"
// Internal Name | NN API? | NN API Name
OP(AddNode , true , ADD)
+OP(SubNode , true , SUB)
OP(Conv2DNode , true , CONV_2D)
OP(DepthwiseConv2DNode , true , DEPTHWISECONV_2D)
OP(AvgPool2DNode , true , AVERAGE_POOL_2D)
--- /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 "SubNode.h"
+
+#include <cassert>
+
+#include "NodeVisitor.h"
+
+namespace neurun
+{
+namespace model
+{
+namespace operation
+{
+
+void SubNode::accept(NodeVisitor &&v) const { v.visit(*this); }
+
+SubNode::SubNode(const operand::IndexSet &inputs, const operand::IndexSet &outputs,
+ const Param ¶m)
+ : model::operation::Node{OperandConstraint::createExact(2u), inputs, outputs}, _param{param}
+{
+}
+
+} // namespace operation
+} // namespace model
+} // namespace neurun
--- /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.
+ */
+
+#ifndef __NEURUN_MODEL_OPERATION_SUB_NODE_H__
+#define __NEURUN_MODEL_OPERATION_SUB_NODE_H__
+
+#include "model/operation/Node.h"
+
+namespace neurun
+{
+namespace model
+{
+namespace operation
+{
+
+class SubNode : public model::operation::Node
+{
+public:
+ enum Input
+ {
+ LHS = 0,
+ RHS
+ };
+
+ struct Param
+ {
+ operand::Index activation_index;
+ };
+
+public:
+ SubNode(const operand::IndexSet &inputs, const operand::IndexSet &outputs, const Param ¶m);
+
+public:
+ virtual void accept(NodeVisitor &&) const override;
+ virtual std::string getName() const override { return "Sub"; }
+
+public:
+ const Param ¶m() const { return _param; }
+
+private:
+ Param _param;
+};
+
+} // namespace operation
+} // namespace model
+} // namespace neurun
+
+#endif // __NEURUN_MODEL_OPERATION_SUB_H__
GeneratedTests.div_*
GeneratedTests.space_to_batch*
GeneratedTests.squeeze*
-GeneratedTests.sub*
GeneratedTests.transpose*
GeneratedTests.cast_ex*
GeneratedTests.gather_ex*
softmax
reshape/reshape1
strided_slice
+sub/broadcast
tanh
MODELS/inception_module
projects / platform / core / ml / nnfw.git / commitdiff