Tensor<float> var_accessor(var_tensor);
for (auto& idx: ShapeRange(scale_tensor.getShape()))
multiplier.at(idx) /= std::sqrt(var_accessor.at(idx) + epsilon);
- result = createOp<ops::ScaleOp>(result->getOutput(0), scale_tensor);
+ auto scale = createOp<ops::ConstantOp>(scale_tensor)->getOutput(0);
+ result = createOp<ops::ScaleOp>(result->getOutput(0), scale);
// overall_res = res2 + bias
auto bias = createOp<ops::ConstantOp>(bias_tensor)->getOutput(0);
bool found;
float value;
std::tie(found, value) = getFloatAttribute(onnx_node, "scale");
- float scale = found ? value : 1.0;
+ float scale_val = found ? value : 1.0;
const auto& shape = inputs[0].op->getOutputShape(inputs[0].index);
- auto result = createOp<ops::ScaleOp>(inputs[0], createTensor(scale, shape));
+ auto scale_tensor = createTensor(scale_val, shape);
+ auto scale = createOp<ops::ConstantOp>(scale_tensor)->getOutput(0);
+ auto result = createOp<ops::ScaleOp>(inputs[0], scale);
return {result->getOutput(0)};
}
std::tie (found, ivalue) = getIntAttribute(onnx_node, "broadcast");
bool broadcast = found ? ivalue : 0;
std::tie (found, fvalue) = getFloatAttribute(onnx_node, "alpha");
- float alpha = found ? fvalue : 1.0;
+ float alpha_val = found ? fvalue : 1.0;
std::tie (found, fvalue) = getFloatAttribute(onnx_node, "beta");
- float beta = found ? fvalue : 1.0;
+ float beta_val = found ? fvalue : 1.0;
// 1. Prepare input matrix A
// Flatten the shape by dim(0)
auto input_a = createOp<ops::ReshapeOp>(inputs[0], shape0);
if (trans_a)
input_a = createOp<ops::TransposeOp>(input_a->getOutput(0), std::vector<std::size_t>{1, 0});
- if (alpha != 1.0)
- input_a = createOp<ops::ScaleOp>(input_a->getOutput(0),
- createTensor(alpha, input_a->getOutputShape(0)));
+ if (alpha_val != 1.0) {
+ auto alpha_tensor = createTensor(alpha_val, input_a->getOutputShape(0));
+ auto alpha = createOp<ops::ConstantOp>(alpha_tensor)->getOutput(0);
+ input_a = createOp<ops::ScaleOp>(input_a->getOutput(0), alpha);
+ }
// 2. Prepare input matrix B
//
// 3. Prepare input matrix C
//
auto input_c = inputs[2];
- auto beta_tensor = createTensor(beta, input_c.op->getOutputShape(0));
+ auto beta_tensor = createTensor(beta_val, input_c.op->getOutputShape(0));
// TODO: check 'broadcast' attribute here
if ((mult_a_b.rank() == 2) && (input_c.op->getOutputShape(0).rank() == 1)) {
beta_tensor = TensorVariant(beta_tensor, mult_a_b);
}
- auto constant = createOp<ops::ConstantOp>(beta_tensor)->getOutput(0);
- std::vector<IODescriptor> descriptors = {constant, input_c};
+ auto beta = createOp<ops::ConstantOp>(beta_tensor)->getOutput(0);
+ std::vector<IODescriptor> descriptors = {beta, input_c};
auto c_mult = createOp<ops::ElementwiseOp>(descriptors, ops::ElementwiseOp::OpType::mul);
assert(c_mult->getOutputShape(0) == mult_a_b);
auto result = createOp<ops::GemmOp>(input_a->getOutput(0), input_b, c_mult->getOutput(0));