forked from mindspore-Ecosystem/mindspore
syn code
This commit is contained in:
commit
3c1785a121
|
|
@ -12,4 +12,4 @@
|
|||
url = https://github.com/protocolbuffers/protobuf.git
|
||||
[submodule "graphengine"]
|
||||
path = graphengine
|
||||
url = https://gitee.com/mindspore/graphengine.git
|
||||
url = https://gitee.com/ms-incubator/graphengine.git
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit 43f5d24337bf785251eefae2d810c7d5684194d6
|
||||
Subproject commit cfc99f95f722918025b0eaeb93440d92265f09fe
|
||||
|
|
@ -230,7 +230,6 @@ const PrimitivePtr kPrimNotInDict = std::make_shared<Primitive>("not_in_dict");
|
|||
const PrimitivePtr kPrimMirror = std::make_shared<Primitive>("_MirrorOperator");
|
||||
const PrimitivePtr kPrimVirtualDiv = std::make_shared<Primitive>("_VirtualDiv");
|
||||
const PrimitivePtr kPrimVirtualDataset = std::make_shared<Primitive>("_VirtualDataset");
|
||||
const PrimitivePtr kPrimAllReduce = std::make_shared<Primitive>("AllReduce");
|
||||
|
||||
// Debug ops
|
||||
const PrimitivePtr kPrimScalarSummary = std::make_shared<Primitive>("ScalarSummary");
|
||||
|
|
|
|||
|
|
@ -234,7 +234,6 @@ extern const PrimitivePtr kPrimInDict;
|
|||
extern const PrimitivePtr kPrimNotInDict;
|
||||
|
||||
// Comm ops
|
||||
extern const PrimitivePtr kPrimAllReduce;
|
||||
extern const PrimitivePtr kPrimMirror;
|
||||
extern const PrimitivePtr kPrimVirtualDiv;
|
||||
extern const PrimitivePtr kPrimVirtualDataset;
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ namespace irpass {
|
|||
OptimizeIRPassLib::OptimizeIRPassLib() {
|
||||
arithmetic_simplify_ = MakeSubstitution(ArithmeticSimplify(), "arithmetic_simplify",
|
||||
{prim::kPrimScalarAdd, prim::kPrimScalarMul, prim::kPrimTensorAdd,
|
||||
prim::kPrimAddN, prim::kPrimIdentity, prim::kPrimMomentum, prim::kPrimMul});
|
||||
prim::kPrimIdentity, prim::kPrimMomentum, prim::kPrimMul});
|
||||
special_op_eliminate_ = MakeSubstitution(SpecialOpEliminater(), "special_op_eliminate",
|
||||
{prim::kPrimInsertGradientOf, prim::kPrimPrintShapeType,
|
||||
prim::kPrimGetRefKey, prim::kPrimMirror, prim::kPrimVirtualDiv});
|
||||
|
|
|
|||
|
|
@ -228,86 +228,6 @@ class ConstantDuplicateMul : public AnfVisitor {
|
|||
CNodePtr cnode_;
|
||||
};
|
||||
|
||||
// grad = AllReduce(grad) / worker_number
|
||||
// grad = grad + weight * decy
|
||||
// ->
|
||||
// grad = grad + weight * decy
|
||||
// grad = AllReduce(grad) / worker_number
|
||||
|
||||
// {prim::kPrimAddN, {prim::kPrimMakeTuple, {prim::kPrimMul, {prim::kPrimAllReduce, X}, Y}, Z}} ->
|
||||
// {prim::kPrimMul, {prim::kPrimAllReduce, {prim::kPrimAddN,{prim::kPrimMakeTuple, Z, X}}}, Y}
|
||||
class AdjustAllReduceMulAdd : public AnfVisitor {
|
||||
public:
|
||||
AnfNodePtr operator()(const OptimizerPtr &, const AnfNodePtr &node) override {
|
||||
Reset();
|
||||
// {prim::kPrimAddN, Zs}
|
||||
if (!IsPrimitiveCNode(node, prim::kPrimAddN)) {
|
||||
return nullptr;
|
||||
}
|
||||
auto addn = node->cast<CNodePtr>();
|
||||
if (addn->size() != 2) {
|
||||
return nullptr;
|
||||
}
|
||||
AnfVisitor::Match(prim::kPrimMakeTuple, {IsNode, IsNode})(addn->input(1));
|
||||
if (x_ == nullptr || y_ == nullptr || z_ == nullptr) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
auto addn_op_node = addn->input(0);
|
||||
auto make_tuple_op_node = addn->input(1)->cast<CNodePtr>()->input(0);
|
||||
auto fg = node->func_graph();
|
||||
AnfNodePtr tuple = NewCNode({make_tuple_op_node, z_, x_}, fg);
|
||||
AnfNodePtr add = NewCNode({addn_op_node, tuple}, fg);
|
||||
AnfNodePtr all_reduce = NewCNode({all_reduce_, add}, fg);
|
||||
return NewCNode({mul_, all_reduce, y_}, fg);
|
||||
}
|
||||
|
||||
void Visit(const AnfNodePtr &node) override {
|
||||
if (level_ == 0) {
|
||||
level_ = 1;
|
||||
is_reduce_match_ = false;
|
||||
// {prim::kPrimMul, {prim::kPrimAllReduce, X}, Y}
|
||||
AnfVisitor::Match(prim::kPrimMul)(node);
|
||||
level_ = 0;
|
||||
if (is_reduce_match_) {
|
||||
mul_ = node->cast<CNodePtr>()->input(0);
|
||||
y_ = tmp_;
|
||||
} else {
|
||||
z_ = node;
|
||||
}
|
||||
}
|
||||
|
||||
if (level_ == 1) {
|
||||
// {prim::kPrimAllReduce, X}
|
||||
if (IsPrimitiveCNode(node, prim::kPrimAllReduce)) {
|
||||
auto cnode = node->cast<CNodePtr>();
|
||||
if (cnode->size() > 1) {
|
||||
all_reduce_ = cnode->input(0);
|
||||
x_ = cnode->input(1);
|
||||
is_reduce_match_ = true;
|
||||
}
|
||||
} else {
|
||||
tmp_ = node;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Reset() {
|
||||
level_ = 0;
|
||||
is_reduce_match_ = false;
|
||||
x_ = nullptr;
|
||||
y_ = nullptr;
|
||||
z_ = nullptr;
|
||||
tmp_ = nullptr;
|
||||
}
|
||||
|
||||
private:
|
||||
int level_{0};
|
||||
bool is_reduce_match_{false};
|
||||
AnfNodePtr x_{nullptr}, y_{nullptr}, z_{nullptr}, tmp_{nullptr};
|
||||
AnfNodePtr all_reduce_{nullptr}, mul_{nullptr};
|
||||
};
|
||||
|
||||
class ArithmeticSimplify {
|
||||
public:
|
||||
ArithmeticSimplify()
|
||||
|
|
@ -323,7 +243,6 @@ class ArithmeticSimplify {
|
|||
eliminaters_.emplace_back(identity_);
|
||||
eliminaters_.emplace_back(opt_update_zero_tensor_);
|
||||
eliminaters_.emplace_back(constant_duplicate_mul_);
|
||||
eliminaters_.emplace_back(adjust_allreduce_mul_add_);
|
||||
}
|
||||
~ArithmeticSimplify() = default;
|
||||
|
||||
|
|
@ -345,7 +264,6 @@ class ArithmeticSimplify {
|
|||
PrimEliminater identity_;
|
||||
OptUpdateZeroTensor opt_update_zero_tensor_;
|
||||
ConstantDuplicateMul constant_duplicate_mul_;
|
||||
AdjustAllReduceMulAdd adjust_allreduce_mul_add_;
|
||||
std::vector<TransformFuncType> eliminaters_{};
|
||||
};
|
||||
} // namespace irpass
|
||||
|
|
|
|||
|
|
@ -96,7 +96,6 @@ const char kNameConfusionMatrix[] = "ConfusionMatrix";
|
|||
const char kNameResizeNearestNeighborD[] = "ResizeNearestNeighbor";
|
||||
const char kNameResizeNearestNeighborGrad[] = "ResizeNearestNeighborGrad";
|
||||
const char kNameApplyAdam[] = "Adam";
|
||||
const char kNameExtractImagePatches[] = "ExtractImagePatches";
|
||||
const char kNameReLU6[] = "ReLU6";
|
||||
const char kNameReLU6Grad[] = "ReLU6Grad";
|
||||
const char kNameElu[] = "Elu";
|
||||
|
|
@ -111,8 +110,6 @@ const char kNameSigmoidCrossEntropyWithLogits[] = "SigmoidCrossEntropyWithLogits
|
|||
const char kNameSigmoidCrossEntropyWithLogitsGrad[] = "SigmoidCrossEntropyWithLogitsGrad";
|
||||
const char kNameScatterNdD[] = "ScatterNd";
|
||||
const char kNamePadD[] = "Pad";
|
||||
const char kNameMirrorPad[] = "MirrorPad";
|
||||
const char kNameMirrorPadGrad[] = "MirrorPadGrad";
|
||||
const char kNameGatherNd[] = "GatherNd";
|
||||
const char kNameArgmax[] = "Argmax";
|
||||
const char kNameArgmin[] = "Argmin";
|
||||
|
|
@ -176,6 +173,7 @@ const char kNameAbsGrad[] = "AbsGrad";
|
|||
const char kNameBinaryCrossEntropy[] = "BinaryCrossEntropy";
|
||||
const char kNameBinaryCrossEntropyGrad[] = "BinaryCrossEntropyGrad";
|
||||
const char kNameSparseApplyAdagrad[] = "SparseApplyAdagrad";
|
||||
const char kNameSparseApplyFtrlD[] = "SparseApplyFtrlD";
|
||||
const char kNameAcosh[] = "Acosh";
|
||||
const char kNameFloorMod[] = "FloorMod";
|
||||
const char kNameSpaceToDepth[] = "SpaceToDepth";
|
||||
|
|
@ -204,7 +202,7 @@ std::unordered_map<std::string, OpAdapterDescPtr> &DfGraphConvertor::get_adpt_ma
|
|||
{string(kNameMaxPool), ADPT_DESC(MaxPool)},
|
||||
{string(kNameAvgPool), ADPT_DESC(AvgPool)},
|
||||
{string(kNameMaxPoolWithArgmax), ADPT_DESC(MaxPoolWithArgmax)},
|
||||
{string(kNameTopK), ADPT_DESC(TopKV2)},
|
||||
{string(kNameTopK), ADPT_DESC(TopK)},
|
||||
{string(kNamePack), ADPT_DESC(Pack)},
|
||||
{string(kNameUnpack), ADPT_DESC(Unpack)},
|
||||
{string(kNameSplitD), ADPT_DESC(SplitD)},
|
||||
|
|
@ -215,7 +213,6 @@ std::unordered_map<std::string, OpAdapterDescPtr> &DfGraphConvertor::get_adpt_ma
|
|||
{string(kNameMaxPoolGrad), ADPT_DESC(MaxPoolGrad)},
|
||||
{string(kNameAvgPoolGrad), ADPT_DESC(AvgPoolGrad)},
|
||||
{string(kNameMaxPoolGradWithArgmax), ADPT_DESC(MaxPoolGradWithArgmax)},
|
||||
{string(kNameExtractImagePatches), ADPT_DESC(ExtractImagePatches)},
|
||||
{prim::kPrimAssign->name(), ADPT_DESC(Assign)},
|
||||
{prim::kPrimStateSetItem->name(), ADPT_DESC(Assign)},
|
||||
{prim::kPrimReluGrad->name(), ADPT_DESC(ReluGrad)},
|
||||
|
|
@ -240,15 +237,15 @@ std::unordered_map<std::string, OpAdapterDescPtr> &DfGraphConvertor::get_adpt_ma
|
|||
{string(kNameSquare), ADPT_DESC(Square)},
|
||||
{prim::kPrimTanh->name(), ADPT_DESC(Tanh)},
|
||||
{prim::kPrimTanhGrad->name(), ADPT_DESC(TanhGrad)},
|
||||
{string(kNameResizeNearestNeighborD), ADPT_DESC(ResizeNearestNeighborD)},
|
||||
{string(kNameResizeNearestNeighborGrad), ADPT_DESC(ResizeNearestNeighborGrad)},
|
||||
{string(kNameResizeNearestNeighborD), ADPT_DESC(ResizeNearestNeighborV2D)},
|
||||
{string(kNameResizeNearestNeighborGrad), ADPT_DESC(ResizeNearestNeighborV2Grad)},
|
||||
{string(kNameApplyAdam), ADPT_DESC(ApplyAdam)},
|
||||
{string(kNameReLU6), ADPT_DESC(Relu6)},
|
||||
{string(kNameReLU6Grad), ADPT_DESC(Relu6Grad)},
|
||||
{string(kNameElu), ADPT_DESC(Elu)},
|
||||
{string(kNameEluGrad), ADPT_DESC(EluGrad)},
|
||||
{string(kNameResizeBilinearGrad), ADPT_DESC(ResizeBilinearGrad)},
|
||||
{string(kNameResizeBilinear), ADPT_DESC(ResizeBilinearD)},
|
||||
{string(kNameResizeBilinearGrad), ADPT_DESC(ResizeBilinearV2Grad)},
|
||||
{string(kNameResizeBilinear), ADPT_DESC(ResizeBilinearV2D)},
|
||||
{string(kNameZerosLike), ADPT_DESC(ZerosLike)},
|
||||
{string(kNameOnesLike), ADPT_DESC(OnesLike)},
|
||||
{string(kNameScatterNdUpdate), ADPT_DESC(ScatterNdUpdate)},
|
||||
|
|
@ -260,8 +257,6 @@ std::unordered_map<std::string, OpAdapterDescPtr> &DfGraphConvertor::get_adpt_ma
|
|||
{string(kNameSigmoidCrossEntropyWithLogitsGrad), ADPT_DESC(SigmoidCrossEntropyWithLogitsGrad)},
|
||||
{string(kNameScatterNdD), ADPT_DESC(ScatterNdD)},
|
||||
{string(kNamePadD), ADPT_DESC(PadD)},
|
||||
{string(kNameMirrorPad), ADPT_DESC(MirrorPad)},
|
||||
{string(kNameMirrorPadGrad), ADPT_DESC(MirrorPadGrad)},
|
||||
{string(kNameGatherNd), ADPT_DESC(GatherNd)},
|
||||
{string(kNameArgmax), ADPT_DESC(ArgMaxD)},
|
||||
{string(kNameArgmin), ADPT_DESC(ArgMinD)},
|
||||
|
|
@ -329,7 +324,7 @@ std::unordered_map<std::string, OpAdapterDescPtr> &DfGraphConvertor::get_adpt_ma
|
|||
{prim::kPrimMinimum->name(), ADPT_DESC(Minimum)},
|
||||
{prim::kPrimSelect->name(), ADPT_DESC(Select)},
|
||||
{string(kNameLessEqual), ADPT_DESC(LessEqual)},
|
||||
{prim::kPrimLogSoftmax->name(), ADPT_DESC(LogSoftmax)},
|
||||
{prim::kPrimLogSoftmax->name(), ADPT_DESC(LogSoftmaxV2)},
|
||||
{string(kNameTruncatedNormal), ADPT_DESC(TruncatedNormal)},
|
||||
{string(kNameStridedSliceGrad), ADPT_DESC(StridedSliceGrad)},
|
||||
{prim::kPrimGelu->name(), ADPT_DESC(Gelu)},
|
||||
|
|
@ -363,7 +358,7 @@ std::unordered_map<std::string, OpAdapterDescPtr> &DfGraphConvertor::get_adpt_ma
|
|||
{prim::kPrimMatMul->name(), ADPT_DESC(MatMul)},
|
||||
|
||||
{string(kNameConst), ADPT_DESC(Constant, Const)},
|
||||
{string(kNameSoftmax), ADPT_DESC(Softmax)},
|
||||
{string(kNameSoftmax), ADPT_DESC(SoftmaxV2)},
|
||||
{string(kNameSoftmaxGrad), ADPT_DESC(SoftmaxGrad)},
|
||||
{string(kNameParam), ADPT_DESC(Data)},
|
||||
{string(kNameROIAlign), ADPT_DESC(ROIAlign)},
|
||||
|
|
@ -373,6 +368,7 @@ std::unordered_map<std::string, OpAdapterDescPtr> &DfGraphConvertor::get_adpt_ma
|
|||
{string(kNameBinaryCrossEntropy), ADPT_DESC(BinaryCrossEntropy)},
|
||||
{string(kNameBinaryCrossEntropyGrad), ADPT_DESC(BinaryCrossEntropyGrad)},
|
||||
{string(kNameSparseApplyAdagrad), ADPT_DESC(SparseApplyAdagradD)},
|
||||
{string(kNameSparseApplyFtrlD), ADPT_DESC(SparseApplyFtrlD)},
|
||||
{string(kNameAcosh), ADPT_DESC(Acosh)},
|
||||
{string(kNameFloorMod), ADPT_DESC(FloorMod)},
|
||||
{string(kNameSpaceToDepth), ADPT_DESC(SpaceToDepth)},
|
||||
|
|
@ -1126,8 +1122,8 @@ void DfGraphConvertor::UpdateDataOpDesc(const AnfNodePtr &it, const OperatorPtr
|
|||
if (desc == nullptr) {
|
||||
MS_LOG(ERROR) << "Update data op descriptor failed! TensorDesc is null.";
|
||||
} else {
|
||||
(void)std::static_pointer_cast<Data>(op)->update_input_desc_data(*desc);
|
||||
(void)std::static_pointer_cast<Data>(op)->update_output_desc_out(*desc);
|
||||
(void)std::static_pointer_cast<Data>(op)->update_input_desc_x(*desc);
|
||||
(void)std::static_pointer_cast<Data>(op)->update_output_desc_y(*desc);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -138,11 +138,10 @@ OUTPUT_MAP(ApplyMomentum) = {{0, OUTPUT_DESC(var)}};
|
|||
INPUT_MAP(Summary) = {{2, INPUT_DESC(x)}};
|
||||
ATTR_MAP(Summary) = EMPTY_ATTR_MAP;
|
||||
|
||||
// data
|
||||
// Data
|
||||
INPUT_MAP(Data) = EMPTY_INPUT_MAP;
|
||||
ATTR_MAP(Data) = EMPTY_ATTR_MAP;
|
||||
|
||||
// resnet ops in ge
|
||||
// BatchNorm
|
||||
INPUT_MAP(BatchNorm) = {{1, INPUT_DESC(x)},
|
||||
{2, INPUT_DESC(scale)},
|
||||
|
|
@ -193,10 +192,9 @@ ATTR_MAP(PRelu) = EMPTY_ATTR_MAP;
|
|||
OUTPUT_MAP(PRelu) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// PReluGrad
|
||||
INPUT_MAP(PReluGrad) = {
|
||||
{1, INPUT_DESC(input_gradients)}, {2, INPUT_DESC(input_features)}, {3, INPUT_DESC(input_weights)}};
|
||||
INPUT_MAP(PReluGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(features)}, {3, INPUT_DESC(weights)}};
|
||||
ATTR_MAP(PReluGrad) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(PReluGrad) = {{0, OUTPUT_DESC(output_backprops_dx)}, {1, OUTPUT_DESC(output_backprops_da)}};
|
||||
OUTPUT_MAP(PReluGrad) = {{0, OUTPUT_DESC(dx)}, {1, OUTPUT_DESC(da)}};
|
||||
|
||||
// Sigmoid
|
||||
INPUT_MAP(Sigmoid) = {{1, INPUT_DESC(x)}};
|
||||
|
|
@ -241,12 +239,12 @@ ATTR_MAP(CumsumD) = {{"exclusive", ATTR_DESC(exclusive, AnyTraits<bool>())},
|
|||
{"reverse", ATTR_DESC(reverse, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(CumsumD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// softmax
|
||||
INPUT_MAP(Softmax) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(Softmax) = {
|
||||
{"axis", ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
// SoftmaxV2
|
||||
INPUT_MAP(SoftmaxV2) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(SoftmaxV2) = {
|
||||
{"axis", ATTR_DESC(axes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
};
|
||||
OUTPUT_MAP(Softmax) = {{0, OUTPUT_DESC(y)}};
|
||||
OUTPUT_MAP(SoftmaxV2) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// SoftmaxGrad
|
||||
INPUT_MAP(SoftmaxGrad) = {{1, INPUT_DESC(softmax)}, {2, INPUT_DESC(grad_softmax)}};
|
||||
|
|
@ -268,17 +266,22 @@ INPUT_MAP(GatherV2) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(indices)}, {3, INPUT_D
|
|||
ATTR_MAP(GatherV2) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(GatherV2) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ReduceSum
|
||||
INPUT_MAP(ReduceSum) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(axes)}};
|
||||
ATTR_MAP(ReduceSum) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ReduceSum) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ReduceSumD
|
||||
INPUT_MAP(ReduceSumD) = {{1, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(ReduceSumD) = {
|
||||
{2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
{2, ATTR_DESC(axes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(ReduceSumD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ReduceSumD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ReduceProdD
|
||||
INPUT_MAP(ReduceProdD) = {{1, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(ReduceProdD) = {
|
||||
{2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
{2, ATTR_DESC(axes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(ReduceProdD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ReduceProdD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
|
|
@ -289,7 +292,7 @@ ATTR_MAP(CumprodD) = {{"exclusive", ATTR_DESC(exclusive, AnyTraits<bool>())},
|
|||
{"reverse", ATTR_DESC(reverse, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(CumprodD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// SoftmaxCrossEntropyWithLogits/
|
||||
// SoftmaxCrossEntropyWithLogits
|
||||
INPUT_MAP(SoftmaxCrossEntropyWithLogits) = {{1, INPUT_DESC(features)}, {2, INPUT_DESC(labels)}};
|
||||
ATTR_MAP(SoftmaxCrossEntropyWithLogits) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(SoftmaxCrossEntropyWithLogits) = {{0, OUTPUT_DESC(loss)}, {1, OUTPUT_DESC(backprop)}};
|
||||
|
|
@ -301,7 +304,7 @@ INPUT_ATTR_MAP(MeanGrad) = {{2, ATTR_DESC(mean_grad_output_shape_value, kOpForma
|
|||
ATTR_MAP(MeanGrad) = {{"mode", ATTR_DESC(mode, AnyTraits<int64_t>())}};
|
||||
|
||||
INPUT_MAP(SliceD) = {{1, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(SliceD) = {{2, ATTR_DESC(begin, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
INPUT_ATTR_MAP(SliceD) = {{2, ATTR_DESC(offsets, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{3, ATTR_DESC(size, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(SliceD) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(SliceD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
|
@ -406,42 +409,10 @@ ATTR_MAP(BoundingBoxDecode) = {
|
|||
};
|
||||
OUTPUT_MAP(BoundingBoxDecode) = {{0, OUTPUT_DESC(bboxes)}};
|
||||
|
||||
#ifdef VALID_CODE
|
||||
|
||||
// Less
|
||||
INPUT_MAP(Less) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}};
|
||||
ATTR_MAP(Less) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(Less) = {{0, OUTPUT_DESC(z)}};
|
||||
|
||||
// Cast
|
||||
INPUT_MAP(Cast) = {{1, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(Cast) = {{2, ATTR_DESC(dst_type, AnyTraits<GEType>())}};
|
||||
ATTR_MAP(Cast) = {{"Truncate", ATTR_DESC(truncate, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(Cast) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// Minimum
|
||||
INPUT_MAP(Minimum) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}};
|
||||
ATTR_MAP(Minimum) = {{"alpha", ATTR_DESC(alpha, AnyTraits<float>())}, {"beta", ATTR_DESC(beta, AnyTraits<float>())}};
|
||||
OUTPUT_MAP(Minimum) = {{0, OUTPUT_DESC(z)}};
|
||||
|
||||
// Sub
|
||||
INPUT_MAP(Sub) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};
|
||||
ATTR_MAP(Sub) = {{"alpha", ATTR_DESC(alpha, AnyTraits<float>())}, {"beta", ATTR_DESC(beta, AnyTraits<float>())}};
|
||||
|
||||
#endif
|
||||
|
||||
// TopKV2
|
||||
INPUT_MAP(TopKV2) = {
|
||||
{1, INPUT_DESC(input)},
|
||||
{2, INPUT_DESC(k)},
|
||||
};
|
||||
|
||||
ATTR_MAP(TopKV2) = {{"T", ATTR_DESC(T, AnyTraits<GEType>())}, {"sorted", ATTR_DESC(sorted, AnyTraits<bool>())}};
|
||||
|
||||
OUTPUT_MAP(TopKV2) = {
|
||||
{0, OUTPUT_DESC(values)},
|
||||
{1, OUTPUT_DESC(indices)},
|
||||
};
|
||||
// TopK
|
||||
INPUT_MAP(TopK) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(k)}};
|
||||
ATTR_MAP(TopK) = {{"sorted", ATTR_DESC(sorted, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(TopK) = {{0, OUTPUT_DESC(values)}, {1, OUTPUT_DESC(indices)}};
|
||||
|
||||
// Multiply
|
||||
INPUT_MAP(Multiply) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}};
|
||||
|
|
@ -481,7 +452,7 @@ ATTR_MAP(Iou) = {{"mode", ATTR_DESC(mode, AnyTraits<std::string>())}};
|
|||
OUTPUT_MAP(Iou) = {{0, OUTPUT_DESC(overlap)}};
|
||||
|
||||
// ResizeNearestNeighborD
|
||||
INPUT_MAP(ResizeNearestNeighborD) = {{1, INPUT_DESC(images)}};
|
||||
INPUT_MAP(ResizeNearestNeighborD) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(ResizeNearestNeighborD) = {
|
||||
{"size", ATTR_DESC(size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"align_corners", ATTR_DESC(align_corners, AnyTraits<bool>())}};
|
||||
|
|
@ -506,9 +477,9 @@ OUTPUT_MAP(ApplyAdam) = {{0, OUTPUT_DESC(var)}};
|
|||
#endif
|
||||
|
||||
// Relu6
|
||||
INPUT_MAP(Relu6) = {{1, INPUT_DESC(features)}};
|
||||
INPUT_MAP(Relu6) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(Relu6) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(Relu6) = {{0, OUTPUT_DESC(activations)}};
|
||||
OUTPUT_MAP(Relu6) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// Relu6Grad
|
||||
INPUT_MAP(Relu6Grad) = {{1, INPUT_DESC(gradients)}, {2, INPUT_DESC(features)}};
|
||||
|
|
@ -520,8 +491,8 @@ INPUT_MAP(ResizeBilinearGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(original
|
|||
ATTR_MAP(ResizeBilinearGrad) = {{"align_corners", ATTR_DESC(align_corners, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ResizeBilinearGrad) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ResizeBilinear
|
||||
INPUT_MAP(ResizeBilinearD) = {{1, INPUT_DESC(images)}};
|
||||
// ResizeBilinearD
|
||||
INPUT_MAP(ResizeBilinearD) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(ResizeBilinearD) = {
|
||||
{"size", ATTR_DESC(size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"align_corners", ATTR_DESC(align_corners, AnyTraits<bool>())}};
|
||||
|
|
@ -544,9 +515,9 @@ OUTPUT_MAP(NMSWithMask) = {
|
|||
{0, OUTPUT_DESC(selected_boxes)}, {1, OUTPUT_DESC(selected_idx)}, {2, OUTPUT_DESC(selected_mask)}};
|
||||
|
||||
// Unpack
|
||||
INPUT_MAP(Unpack) = {{1, INPUT_DESC(value)}};
|
||||
INPUT_MAP(Unpack) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(Unpack) = {{"axis", ATTR_DESC(axis, AnyTraits<int>())}, {"num", ATTR_DESC(num, AnyTraits<int>())}};
|
||||
DYN_OUTPUT_MAP(Unpack) = {{0, DYN_OUTPUT_DESC(output)}};
|
||||
DYN_OUTPUT_MAP(Unpack) = {{0, DYN_OUTPUT_DESC(y)}};
|
||||
|
||||
// ScatterNdUpdate
|
||||
INPUT_MAP(ScatterNdUpdate) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(indices)}, {3, INPUT_DESC(updates)}};
|
||||
|
|
@ -579,8 +550,8 @@ INPUT_MAP(SigmoidCrossEntropyWithLogitsGrad) = {
|
|||
ATTR_MAP(SigmoidCrossEntropyWithLogitsGrad) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(SigmoidCrossEntropyWithLogitsGrad) = {{0, OUTPUT_DESC(gradient)}};
|
||||
|
||||
// ScatterNd
|
||||
INPUT_MAP(ScatterNdD) = {{1, INPUT_DESC(indices)}, {2, INPUT_DESC(updates)}};
|
||||
// ScatterNdD
|
||||
INPUT_MAP(ScatterNdD) = {{1, INPUT_DESC(indices)}, {2, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(ScatterNdD) = {
|
||||
{3, ATTR_DESC(shape, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(ScatterNdD) = EMPTY_ATTR_MAP;
|
||||
|
|
@ -591,24 +562,14 @@ INPUT_MAP(PadD) = {{1, INPUT_DESC(x)}};
|
|||
ATTR_MAP(PadD) = {{"paddings", ATTR_DESC(paddings, AnyTraits<std::vector<std::vector<int64_t>>>())}};
|
||||
OUTPUT_MAP(PadD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// MirrorPad
|
||||
INPUT_MAP(MirrorPad) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(paddings)}};
|
||||
ATTR_MAP(MirrorPad) = {{"mode", ATTR_DESC(mode, AnyTraits<std::string>())}};
|
||||
OUTPUT_MAP(MirrorPad) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// MirrorPadGrad
|
||||
INPUT_MAP(MirrorPadGrad) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(paddings)}};
|
||||
ATTR_MAP(MirrorPadGrad) = {{"mode", ATTR_DESC(mode, AnyTraits<std::string>())}};
|
||||
OUTPUT_MAP(MirrorPadGrad) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// GatherNd
|
||||
INPUT_MAP(GatherNd) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};
|
||||
INPUT_MAP(GatherNd) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(indices)}};
|
||||
ATTR_MAP(GatherNd) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(GatherNd) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ROIAlign
|
||||
INPUT_MAP(ROIAlign) = {{1, INPUT_DESC(features)}, {2, INPUT_DESC(rois)}};
|
||||
OUTPUT_MAP(ROIAlign) = {{0, OUTPUT_DESC(output)}};
|
||||
OUTPUT_MAP(ROIAlign) = {{0, OUTPUT_DESC(y)}};
|
||||
ATTR_MAP(ROIAlign) = {{"pooled_height", ATTR_DESC(pooled_height, AnyTraits<int>())},
|
||||
{"pooled_width", ATTR_DESC(pooled_width, AnyTraits<int>())},
|
||||
{"spatial_scale", ATTR_DESC(spatial_scale, AnyTraits<float>())},
|
||||
|
|
@ -627,13 +588,13 @@ ATTR_MAP(ROIAlignGrad) = {
|
|||
// ArgMaxD
|
||||
INPUT_MAP(ArgMaxD) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(ArgMaxD) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},
|
||||
{"output_type", ATTR_DESC(output_type, AnyTraits<GEType>())}};
|
||||
{"output_type", ATTR_DESC(dtype, AnyTraits<GEType>())}};
|
||||
OUTPUT_MAP(ArgMaxD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ArgMinD
|
||||
INPUT_MAP(ArgMinD) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(ArgMinD) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},
|
||||
{"output_type", ATTR_DESC(output_type, AnyTraits<GEType>())}};
|
||||
{"output_type", ATTR_DESC(dtype, AnyTraits<GEType>())}};
|
||||
OUTPUT_MAP(ArgMinD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ArgMaxWithValue
|
||||
|
|
@ -648,17 +609,15 @@ ATTR_MAP(ArgMinWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},
|
|||
{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ArgMinWithValue) = {{0, OUTPUT_DESC(indice)}, {1, OUTPUT_DESC(values)}};
|
||||
|
||||
// ReduceAllD
|
||||
INPUT_MAP(ReduceAllD) = {{1, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(ReduceAllD) = {
|
||||
{2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(ReduceAllD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ReduceAllD) = {{0, OUTPUT_DESC(y)}};
|
||||
// ReduceAll
|
||||
INPUT_MAP(ReduceAll) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(axes)}};
|
||||
ATTR_MAP(ReduceAll) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ReduceAll) = {{0, OUTPUT_DESC(y)}}
|
||||
|
||||
// ReduceMeanD
|
||||
INPUT_MAP(ReduceMeanD) = {{1, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(ReduceMeanD) = {
|
||||
{2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
{2, ATTR_DESC(axes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(ReduceMeanD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ReduceMeanD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
|
|
@ -725,11 +684,12 @@ INPUT_MAP(BiasAddGrad) = {{1, INPUT_DESC(x)}};
|
|||
ATTR_MAP(BiasAddGrad) = {{"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
|
||||
OUTPUT_MAP(BiasAddGrad) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// maxpoolgrad
|
||||
// MaxPoolGrad
|
||||
INPUT_MAP(MaxPoolGrad) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {3, INPUT_DESC(grad)}};
|
||||
ATTR_MAP(MaxPoolGrad) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};
|
||||
{"padding", ATTR_DESC(padding, AnyTraits<std::string>())},
|
||||
{"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
|
||||
OUTPUT_MAP(MaxPoolGrad) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// avgpoolgrad
|
||||
|
|
@ -748,20 +708,16 @@ ATTR_MAP(MaxPoolWithArgmax) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyT
|
|||
OUTPUT_MAP(MaxPoolWithArgmax) = {{0, OUTPUT_DESC(y)}, {1, OUTPUT_DESC(argmax)}};
|
||||
|
||||
// MaxPoolGradWithArgmax
|
||||
INPUT_MAP(MaxPoolGradWithArgmax) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(grad)}, {3, INPUT_DESC(argmax)}};
|
||||
INPUT_MAP(MaxPoolGradWithArgmax) = {
|
||||
{1, INPUT_DESC(x)},
|
||||
{2, INPUT_DESC(grad)},
|
||||
{3, INPUT_DESC(argmax)},
|
||||
};
|
||||
ATTR_MAP(MaxPoolGradWithArgmax) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};
|
||||
OUTPUT_MAP(MaxPoolGradWithArgmax) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ExtractImagePatches
|
||||
INPUT_MAP(ExtractImagePatches) = {{1, INPUT_DESC(images)}};
|
||||
ATTR_MAP(ExtractImagePatches) = {{"ksizes", ATTR_DESC(ksizes, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"rates", ATTR_DESC(rates, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};
|
||||
OUTPUT_MAP(ExtractImagePatches) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// Conv2D
|
||||
INPUT_MAP(Conv2D) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(filter)}};
|
||||
ATTR_MAP(Conv2D) = {
|
||||
|
|
@ -772,9 +728,9 @@ ATTR_MAP(Conv2D) = {
|
|||
OUTPUT_MAP(Conv2D) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// Conv2DBackpropInputD
|
||||
INPUT_MAP(Conv2DBackpropInputD) = {{1, INPUT_DESC(out_backprop)}, {2, INPUT_DESC(filters)}};
|
||||
INPUT_MAP(Conv2DBackpropInputD) = {{1, INPUT_DESC(out_backprop)}, {2, INPUT_DESC(filter)}};
|
||||
INPUT_ATTR_MAP(Conv2DBackpropInputD) = {
|
||||
{3, ATTR_DESC(input_sizes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
{3, ATTR_DESC(input_size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(Conv2DBackpropInputD) = {
|
||||
{"pad_list", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"stride", ATTR_DESC(strides, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
|
|
@ -785,7 +741,7 @@ OUTPUT_MAP(Conv2DBackpropInputD) = {{0, OUTPUT_DESC(y)}};
|
|||
// Conv2DBackpropFilterD
|
||||
INPUT_MAP(Conv2DBackpropFilterD) = {{1, INPUT_DESC(out_backprop)}, {2, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(Conv2DBackpropFilterD) = {
|
||||
{3, ATTR_DESC(filter_sizes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
{3, ATTR_DESC(filter_size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(Conv2DBackpropFilterD) = {
|
||||
{"pad_list", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"stride", ATTR_DESC(strides, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
|
|
@ -796,9 +752,9 @@ OUTPUT_MAP(Conv2DBackpropFilterD) = {{0, OUTPUT_DESC(y)}};
|
|||
// DepthwiseConv2D
|
||||
INPUT_MAP(DepthwiseConv2D) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(filter)}};
|
||||
ATTR_MAP(DepthwiseConv2D) = {
|
||||
{"stride", ATTR_DESC(strides, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"stride", ATTR_DESC(strides, "pad", AnyTraits<std::vector<int64_t>>())},
|
||||
{"pads", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"dilation", ATTR_DESC(dilations, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},
|
||||
{"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())},
|
||||
};
|
||||
OUTPUT_MAP(DepthwiseConv2D) = {{0, OUTPUT_DESC(y)}};
|
||||
|
|
@ -808,9 +764,9 @@ INPUT_MAP(DepthwiseConv2DBackpropInputD) = {{2, INPUT_DESC(filter)}, {3, INPUT_D
|
|||
INPUT_ATTR_MAP(DepthwiseConv2DBackpropInputD) = {
|
||||
{1, ATTR_DESC(input_size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(DepthwiseConv2DBackpropInputD) = {
|
||||
{"stride", ATTR_DESC(strides, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"stride", ATTR_DESC(strides, "pad", AnyTraits<std::vector<int64_t>>())},
|
||||
{"pads", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"dilation", ATTR_DESC(dilations, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},
|
||||
};
|
||||
OUTPUT_MAP(DepthwiseConv2DBackpropInputD) = {{0, OUTPUT_DESC(input_grad)}};
|
||||
|
||||
|
|
@ -819,16 +775,16 @@ INPUT_MAP(DepthwiseConv2DBackpropFilterD) = {{1, INPUT_DESC(input)}, {3, INPUT_D
|
|||
INPUT_ATTR_MAP(DepthwiseConv2DBackpropFilterD) = {
|
||||
{2, ATTR_DESC(filter_size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(DepthwiseConv2DBackpropFilterD) = {
|
||||
{"stride", ATTR_DESC(strides, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"stride", ATTR_DESC(strides, "pad", AnyTraits<std::vector<int64_t>>())},
|
||||
{"pads", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"dilation", ATTR_DESC(dilations, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
|
||||
{"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},
|
||||
};
|
||||
OUTPUT_MAP(DepthwiseConv2DBackpropFilterD) = {{0, OUTPUT_DESC(filter_grad)}};
|
||||
|
||||
// MatMul
|
||||
INPUT_MAP(MatMul) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};
|
||||
ATTR_MAP(MatMul) = {{"transpose_a", ATTR_DESC(transpose_a, AnyTraits<bool>())},
|
||||
{"transpose_b", ATTR_DESC(transpose_b, AnyTraits<bool>())}};
|
||||
ATTR_MAP(MatMul) = {{"transpose_a", ATTR_DESC(transpose_x1, AnyTraits<bool>())},
|
||||
{"transpose_b", ATTR_DESC(transpose_x2, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(MatMul) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// Merge
|
||||
|
|
@ -875,10 +831,10 @@ ATTR_MAP(Sub) = EMPTY_ATTR_MAP;
|
|||
OUTPUT_MAP(Sub) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// SplitD
|
||||
INPUT_MAP(SplitD) = {{1, INPUT_DESC(value)}};
|
||||
INPUT_MAP(SplitD) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(SplitD) = {{"axis", ATTR_DESC(split_dim, AnyTraits<int>())},
|
||||
{"output_num", ATTR_DESC(num_split, AnyTraits<int>())}};
|
||||
DYN_OUTPUT_MAP(SplitD) = {{0, DYN_OUTPUT_DESC(output)}};
|
||||
DYN_OUTPUT_MAP(SplitD) = {{0, DYN_OUTPUT_DESC(y)}};
|
||||
|
||||
// Neg
|
||||
INPUT_MAP(Neg) = {{1, INPUT_DESC(x)}};
|
||||
|
|
@ -905,12 +861,12 @@ OUTPUT_MAP(Pack) = {{0, OUTPUT_DESC(y)}};
|
|||
|
||||
// ConcatD
|
||||
INPUT_MAP(ConcatD) = EMPTY_INPUT_MAP;
|
||||
DYN_INPUT_MAP(ConcatD) = {{1, DYN_INPUT_DESC(input_values)}};
|
||||
DYN_INPUT_MAP(ConcatD) = {{1, DYN_INPUT_DESC(x)}};
|
||||
ATTR_MAP(ConcatD) = {
|
||||
{"axis", ATTR_DESC(concat_dim, AnyTraits<int>())},
|
||||
{"inputNums", ATTR_DESC(N, AnyTraits<int>())},
|
||||
};
|
||||
OUTPUT_MAP(ConcatD) = {{0, OUTPUT_DESC(output_data)}};
|
||||
OUTPUT_MAP(ConcatD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// Less
|
||||
INPUT_MAP(Less) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};
|
||||
|
|
@ -945,14 +901,14 @@ OUTPUT_MAP(TanhGrad) = {{0, OUTPUT_DESC(z)}};
|
|||
// ReduceMinD
|
||||
INPUT_MAP(ReduceMinD) = {{1, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(ReduceMinD) = {
|
||||
{2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
{2, ATTR_DESC(axes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(ReduceMinD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ReduceMinD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// ReduceMaxD
|
||||
INPUT_MAP(ReduceMaxD) = {{1, INPUT_DESC(x)}};
|
||||
INPUT_ATTR_MAP(ReduceMaxD) = {
|
||||
{2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
{2, ATTR_DESC(axes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
ATTR_MAP(ReduceMaxD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(ReduceMaxD) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
|
|
@ -1037,11 +993,11 @@ INPUT_MAP(LessEqual) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};
|
|||
ATTR_MAP(LessEqual) = EMPTY_ATTR_MAP;
|
||||
OUTPUT_MAP(LessEqual) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// LogSoftmax
|
||||
INPUT_MAP(LogSoftmax) = {{1, INPUT_DESC(logits)}};
|
||||
ATTR_MAP(LogSoftmax) = {
|
||||
{"axis", ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
OUTPUT_MAP(LogSoftmax) = {{0, OUTPUT_DESC(logsoftmax)}};
|
||||
// LogSoftmaxV2
|
||||
INPUT_MAP(LogSoftmaxV2) = {{1, INPUT_DESC(logits)}};
|
||||
ATTR_MAP(LogSoftmaxV2) = {
|
||||
{"axis", ATTR_DESC(axes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
|
||||
OUTPUT_MAP(LogSoftmaxV2) = {{0, OUTPUT_DESC(logsoftmax)}};
|
||||
|
||||
// RandomChoiceWithMask
|
||||
INPUT_MAP(RandomChoiceWithMask) = {{1, INPUT_DESC(x)}};
|
||||
|
|
@ -1123,8 +1079,8 @@ OUTPUT_MAP(LayerNormGrad) = {{0, OUTPUT_DESC(pd_x)}, {1, OUTPUT_DESC(pd_gamma)},
|
|||
|
||||
// BatchMatMul
|
||||
INPUT_MAP(BatchMatMul) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};
|
||||
ATTR_MAP(BatchMatMul) = {{"transpose_x1", ATTR_DESC(adj_x, AnyTraits<bool>())},
|
||||
{"transpose_x2", ATTR_DESC(adj_y, AnyTraits<bool>())}};
|
||||
ATTR_MAP(BatchMatMul) = {{"transpose_x1", ATTR_DESC(adj_x1, AnyTraits<bool>())},
|
||||
{"transpose_x2", ATTR_DESC(adj_x2, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(BatchMatMul) = {{0, OUTPUT_DESC(y)}};
|
||||
|
||||
// DropoutDoMask
|
||||
|
|
@ -1175,6 +1131,19 @@ ATTR_MAP(SparseApplyAdagradD) = {{"lr", ATTR_DESC(lr, AnyTraits<float>())},
|
|||
{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||||
OUTPUT_MAP(SparseApplyAdagradD) = {{0, OUTPUT_DESC(var)}};
|
||||
|
||||
// SparseApplyFtrlD
|
||||
INPUT_MAP(SparseApplyFtrlD) = {{1, INPUT_DESC(var)},
|
||||
{2, INPUT_DESC(accum)},
|
||||
{3, INPUT_DESC(linear)},
|
||||
{4, INPUT_DESC(grad)},
|
||||
{5, INPUT_DESC(indices)}};
|
||||
ATTR_MAP(SparseApplyFtrlD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())},
|
||||
{"lr", ATTR_DESC(lr, AnyTraits<float>())},
|
||||
{"l1", ATTR_DESC(l1, AnyTraits<float>())},
|
||||
{"l2", ATTR_DESC(l2, AnyTraits<float>())},
|
||||
{"lr_power", ATTR_DESC(lr_power, AnyTraits<float>())}};
|
||||
OUTPUT_MAP(SparseApplyFtrlD) = {{0, OUTPUT_DESC(var)}};
|
||||
|
||||
// SpaceToDepth
|
||||
INPUT_MAP(SpaceToDepth) = {{1, INPUT_DESC(x)}};
|
||||
ATTR_MAP(SpaceToDepth) = {{"block_size", ATTR_DESC(block_size, AnyTraits<int64_t>())}};
|
||||
|
|
|
|||
|
|
@ -95,8 +95,6 @@ DECLARE_OP_USE_OUTPUT(MaxPoolGradWithArgmax)
|
|||
DECLARE_OP_ADAPTER(Conv2D)
|
||||
DECLARE_OP_USE_ENUM(Conv2D)
|
||||
DECLARE_OP_USE_OUTPUT(Conv2D)
|
||||
DECLARE_OP_ADAPTER(ExtractImagePatches)
|
||||
DECLARE_OP_USE_OUTPUT(ExtractImagePatches)
|
||||
DECLARE_OP_ADAPTER(Conv2DBackpropInputD)
|
||||
DECLARE_OP_USE_ENUM(Conv2DBackpropInputD)
|
||||
DECLARE_OP_USE_INPUT_ATTR(Conv2DBackpropInputD)
|
||||
|
|
@ -118,20 +116,20 @@ DECLARE_OP_ADAPTER(Reshape)
|
|||
DECLARE_OP_USE_OUTPUT(Reshape)
|
||||
DECLARE_OP_ADAPTER(Iou)
|
||||
DECLARE_OP_USE_OUTPUT(Iou)
|
||||
DECLARE_OP_ADAPTER(ResizeNearestNeighborD)
|
||||
DECLARE_OP_USE_OUTPUT(ResizeNearestNeighborD)
|
||||
DECLARE_OP_ADAPTER(ResizeNearestNeighborGrad)
|
||||
DECLARE_OP_USE_OUTPUT(ResizeNearestNeighborGrad)
|
||||
DECLARE_OP_ADAPTER(ResizeNearestNeighborV2D)
|
||||
DECLARE_OP_USE_OUTPUT(ResizeNearestNeighborV2D)
|
||||
DECLARE_OP_ADAPTER(ResizeNearestNeighborV2Grad)
|
||||
DECLARE_OP_USE_OUTPUT(ResizeNearestNeighborV2Grad)
|
||||
DECLARE_OP_ADAPTER(ApplyAdam)
|
||||
DECLARE_OP_USE_OUTPUT(ApplyAdam)
|
||||
DECLARE_OP_ADAPTER(Relu6)
|
||||
DECLARE_OP_USE_OUTPUT(Relu6)
|
||||
DECLARE_OP_ADAPTER(Relu6Grad)
|
||||
DECLARE_OP_USE_OUTPUT(Relu6Grad)
|
||||
DECLARE_OP_ADAPTER(ResizeBilinearD)
|
||||
DECLARE_OP_USE_OUTPUT(ResizeBilinearD)
|
||||
DECLARE_OP_ADAPTER(ResizeBilinearGrad)
|
||||
DECLARE_OP_USE_OUTPUT(ResizeBilinearGrad)
|
||||
DECLARE_OP_ADAPTER(ResizeBilinearV2D)
|
||||
DECLARE_OP_USE_OUTPUT(ResizeBilinearV2D)
|
||||
DECLARE_OP_ADAPTER(ResizeBilinearV2Grad)
|
||||
DECLARE_OP_USE_OUTPUT(ResizeBilinearV2Grad)
|
||||
DECLARE_OP_ADAPTER(ZerosLike)
|
||||
DECLARE_OP_USE_OUTPUT(ZerosLike)
|
||||
DECLARE_OP_ADAPTER(OnesLike)
|
||||
|
|
@ -157,10 +155,6 @@ DECLARE_OP_USE_INPUT_ATTR(ScatterNdD)
|
|||
DECLARE_OP_USE_OUTPUT(ScatterNdD)
|
||||
DECLARE_OP_ADAPTER(PadD)
|
||||
DECLARE_OP_USE_OUTPUT(PadD)
|
||||
DECLARE_OP_ADAPTER(MirrorPad)
|
||||
DECLARE_OP_USE_OUTPUT(MirrorPad)
|
||||
DECLARE_OP_ADAPTER(MirrorPadGrad)
|
||||
DECLARE_OP_USE_OUTPUT(MirrorPadGrad)
|
||||
DECLARE_OP_ADAPTER(BoundingBoxEncode)
|
||||
DECLARE_OP_USE_OUTPUT(BoundingBoxEncode)
|
||||
DECLARE_OP_ADAPTER(BoundingBoxDecode)
|
||||
|
|
@ -217,8 +211,8 @@ DECLARE_OP_USE_OUTPUT(Merge)
|
|||
DECLARE_OP_ADAPTER(Switch)
|
||||
DECLARE_OP_USE_OUTPUT(Switch)
|
||||
|
||||
DECLARE_OP_ADAPTER(TopKV2)
|
||||
DECLARE_OP_USE_OUTPUT(TopKV2)
|
||||
DECLARE_OP_ADAPTER(TopK)
|
||||
DECLARE_OP_USE_OUTPUT(TopK)
|
||||
|
||||
DECLARE_OP_ADAPTER(RealDiv)
|
||||
DECLARE_OP_USE_OUTPUT(RealDiv)
|
||||
|
|
@ -268,8 +262,8 @@ DECLARE_OP_ADAPTER(Select)
|
|||
DECLARE_OP_USE_OUTPUT(Select)
|
||||
DECLARE_OP_ADAPTER(LessEqual)
|
||||
DECLARE_OP_USE_OUTPUT(LessEqual)
|
||||
DECLARE_OP_ADAPTER(LogSoftmax)
|
||||
DECLARE_OP_USE_OUTPUT(LogSoftmax)
|
||||
DECLARE_OP_ADAPTER(LogSoftmaxV2)
|
||||
DECLARE_OP_USE_OUTPUT(LogSoftmaxV2)
|
||||
DECLARE_OP_ADAPTER(TruncatedNormal)
|
||||
DECLARE_OP_USE_OUTPUT(TruncatedNormal)
|
||||
DECLARE_OP_ADAPTER(StridedSliceGrad)
|
||||
|
|
@ -402,8 +396,8 @@ DECLARE_OP_ADAPTER(Sigmoid)
|
|||
DECLARE_OP_USE_OUTPUT(Sigmoid)
|
||||
DECLARE_OP_ADAPTER(SigmoidGrad)
|
||||
DECLARE_OP_USE_OUTPUT(SigmoidGrad)
|
||||
DECLARE_OP_ADAPTER(Softmax)
|
||||
DECLARE_OP_USE_OUTPUT(Softmax)
|
||||
DECLARE_OP_ADAPTER(SoftmaxV2)
|
||||
DECLARE_OP_USE_OUTPUT(SoftmaxV2)
|
||||
DECLARE_OP_ADAPTER(SoftmaxGrad)
|
||||
DECLARE_OP_USE_OUTPUT(SoftmaxGrad)
|
||||
DECLARE_OP_ADAPTER(Greater)
|
||||
|
|
@ -446,6 +440,8 @@ DECLARE_OP_ADAPTER(Round)
|
|||
DECLARE_OP_USE_OUTPUT(Round)
|
||||
DECLARE_OP_ADAPTER(ApplyFtrl)
|
||||
DECLARE_OP_USE_OUTPUT(ApplyFtrl)
|
||||
DECLARE_OP_ADAPTER(SparseApplyFtrlD)
|
||||
DECLARE_OP_USE_OUTPUT(SparseApplyFtrlD)
|
||||
DECLARE_OP_ADAPTER(Diag)
|
||||
DECLARE_OP_USE_OUTPUT(Diag)
|
||||
DECLARE_OP_ADAPTER(DiagPart)
|
||||
|
|
|
|||
|
|
@ -1235,8 +1235,8 @@ class UnsortedSegmentSum(PrimitiveWithInfer):
|
|||
Tensor, the shape is :math:`(z, x_{N+1}, ..., x_R)`.
|
||||
|
||||
Examples:
|
||||
>>> input_x = Tensor([1, 2, 3, 4], mindspore.float32)
|
||||
>>> segment_ids = Tensor([0, 0, 1, 2], mindspore.int32)
|
||||
>>> input_x = [1, 2, 3, 4]
|
||||
>>> segment_ids = [0, 0, 1, 2]
|
||||
>>> num_segments = 4
|
||||
>>> P.UnsortedSegmentSum()(input_x, segment_ids, num_segments)
|
||||
[3, 3, 4, 0]
|
||||
|
|
|
|||
|
|
@ -1630,7 +1630,7 @@ class LayerNorm(Primitive):
|
|||
`Layer Normalization <https://arxiv.org/abs/1607.06450>`_.
|
||||
|
||||
.. math::
|
||||
y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
|
||||
y = \frac{x - mean]}{\sqrt{variance + \epsilon}} * \gamma + \beta
|
||||
|
||||
where :math:`\gamma` is scale, :math:`\beta` is bias, :math:`\epsilon` is epsilon.
|
||||
|
||||
|
|
|
|||
|
|
@ -556,24 +556,5 @@ TEST_F(TestOptLib, test_constant_duplicate_mul) {
|
|||
ASSERT_TRUE(CheckOpt(beforerl, after, patterns));
|
||||
ASSERT_TRUE(CheckOpt(beforerr, after, patterns));
|
||||
}
|
||||
|
||||
TEST_F(TestOptLib, test_adjust_allreduce_mul_add) {
|
||||
FuncGraphPtr beforell = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "beforell");
|
||||
FuncGraphPtr beforelr = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "beforelr");
|
||||
FuncGraphPtr beforerl = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "beforerl");
|
||||
FuncGraphPtr beforerr = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "beforerr");
|
||||
FuncGraphPtr after1 = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "after1");
|
||||
FuncGraphPtr before2r = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "before2r");
|
||||
FuncGraphPtr before2l = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "before2l");
|
||||
FuncGraphPtr after2 = getPyFun.CallAndParseRet("test_adjust_allreduce_mul_add", "after2");
|
||||
auto patterns = std::vector<SubstitutionPtr>({irpass.arithmetic_simplify_});
|
||||
ASSERT_TRUE(CheckOpt(beforell, after1, patterns));
|
||||
ASSERT_TRUE(CheckOpt(beforelr, after1, patterns));
|
||||
ASSERT_TRUE(CheckOpt(beforerl, after1, patterns));
|
||||
ASSERT_TRUE(CheckOpt(beforerr, after1, patterns));
|
||||
ASSERT_TRUE(CheckOpt(before2l, after2, patterns));
|
||||
ASSERT_TRUE(CheckOpt(before2r, after2, patterns));
|
||||
}
|
||||
|
||||
} // namespace opt
|
||||
} // namespace mindspore
|
||||
|
|
|
|||
|
|
@ -908,8 +908,8 @@ def test_print_tuple_wrapper(tag):
|
|||
|
||||
def test_constant_duplicate_mul(tag):
|
||||
fns = FnDict()
|
||||
Mul = Primitive('Mul')
|
||||
Sqrt = Primitive('Sqrt')
|
||||
Mul = Primitive('Mul');
|
||||
Sqrt = Primitive('Sqrt');
|
||||
|
||||
x = Tensor(np.array([[2, 2], [2, 3]]).astype('float32'))
|
||||
tensor1 = Tensor(np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32'))
|
||||
|
|
@ -936,44 +936,3 @@ def test_constant_duplicate_mul(tag):
|
|||
return Mul(Sqrt(x), Mul(tensor1, tensor2))
|
||||
|
||||
return fns[tag]
|
||||
|
||||
|
||||
def test_adjust_allreduce_mul_add(tag):
|
||||
fns = FnDict()
|
||||
Mul = Primitive('Mul')
|
||||
AddN = Primitive('AddN')
|
||||
AllReduce = Primitive('AllReduce')
|
||||
|
||||
@fns
|
||||
def beforell(x, y, z):
|
||||
return AddN((z, Mul(y, AllReduce(x))))
|
||||
|
||||
@fns
|
||||
def beforelr(x, y, z):
|
||||
return AddN((z, Mul(AllReduce(x), y)))
|
||||
|
||||
@fns
|
||||
def beforerl(x, y, z):
|
||||
return AddN((Mul(y, AllReduce(x)), z))
|
||||
|
||||
@fns
|
||||
def beforerr(x, y, z):
|
||||
return AddN((Mul(AllReduce(x), y), z))
|
||||
|
||||
@fns
|
||||
def after1(x, y, z):
|
||||
return Mul(AllReduce(AddN((z, x))), y)
|
||||
|
||||
@fns
|
||||
def before2r(x, y, z):
|
||||
return AddN((Mul(AllReduce(x), y), Mul(z, z)))
|
||||
|
||||
@fns
|
||||
def before2l(x, y, z):
|
||||
return AddN((Mul(z, z), Mul(AllReduce(x), y)))
|
||||
|
||||
@fns
|
||||
def after2(x, y, z):
|
||||
return Mul(AllReduce(AddN((Mul(z, z), x))), y)
|
||||
|
||||
return fns[tag]
|
||||
|
|
|
|||
Loading…
Reference in New Issue