in tensorflow/tensorflow/lite/toco/export_tensorflow.cc [2098:2392]
void ConvertOperator(const Model& model, const Operator& src_op,
GraphDef* tensorflow_graph) {
if (src_op.fused_activation_function != FusedActivationFunctionType::kNone) {
LOG(FATAL)
<< "Unsupported: the input model has a fused activation function";
}
if (src_op.type == OperatorType::kConv) {
ConvertConvOperator(model, static_cast<const ConvOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kDepthwiseConv) {
ConvertDepthwiseConvOperator(
model, static_cast<const DepthwiseConvOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kDepthToSpace) {
ConvertDepthToSpaceOperator(
model, static_cast<const DepthToSpaceOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kSpaceToDepth) {
ConvertSpaceToDepthOperator(
model, static_cast<const SpaceToDepthOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kFullyConnected) {
ConvertFullyConnectedOperator(
model, static_cast<const FullyConnectedOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kAdd) {
ConvertAddOperator(model, static_cast<const AddOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kAddN) {
ConvertAddNOperator(model, static_cast<const AddNOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kMul) {
ConvertMulOperator(model, static_cast<const MulOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kDiv) {
ConvertDivOperator(model, static_cast<const DivOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kRelu) {
ConvertReluOperator(model, static_cast<const ReluOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kRelu1) {
ConvertRelu1Operator(static_cast<const Relu1Operator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kRelu6) {
ConvertRelu6Operator(static_cast<const Relu6Operator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kLog) {
ConvertLogOperator(static_cast<const LogOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kLogistic) {
ConvertLogisticOperator(static_cast<const LogisticOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kTanh) {
ConvertTanhOperator(static_cast<const TanhOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kL2Normalization) {
ConvertL2NormalizationOperator(
static_cast<const L2NormalizationOperator&>(src_op), tensorflow_graph);
} else if (src_op.type == OperatorType::kSoftmax) {
ConvertSoftmaxOperator(model, static_cast<const SoftmaxOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kLogSoftmax) {
ConvertLogSoftmaxOperator(model,
static_cast<const LogSoftmaxOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kLocalResponseNormalization) {
ConvertLocalResponseNormalizationOperator(
static_cast<const LocalResponseNormalizationOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kLstmCell) {
ConvertLstmCellOperator(model, static_cast<const LstmCellOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kMaxPool) {
ConvertMaxPoolOperator(static_cast<const MaxPoolOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kAveragePool) {
ConvertAveragePoolOperator(static_cast<const AveragePoolOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kConcatenation) {
ConvertConcatenationOperator(
model, static_cast<const ConcatenationOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kReshape) {
ConvertTensorFlowReshapeOperator(
model, static_cast<const TensorFlowReshapeOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kL2Pool) {
ConvertL2PoolOperator(static_cast<const L2PoolOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kSquare) {
ConvertSquareOperator(static_cast<const TensorFlowSquareOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kSqrt) {
ConvertSqrtOperator(static_cast<const TensorFlowSqrtOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kRsqrt) {
ConvertRsqrtOperator(model,
static_cast<const TensorFlowRsqrtOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kSplit) {
ConvertSplitOperator(model,
static_cast<const TensorFlowSplitOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kSplitV) {
ConvertSplitVOperator(model,
static_cast<const TensorFlowSplitVOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kFakeQuant) {
ConvertFakeQuantOperator(static_cast<const FakeQuantOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kCast) {
ConvertCastOperator(model, static_cast<const CastOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kFloor) {
ConvertFloorOperator(model, static_cast<const FloorOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kCeil) {
ConvertCeilOperator(model, static_cast<const CeilOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kRound) {
ConvertRoundOperator(model, static_cast<const RoundOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kGather) {
ConvertGatherOperator(model, static_cast<const GatherOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kResizeBilinear) {
ConvertResizeBilinearOperator(
model, static_cast<const ResizeBilinearOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kSpaceToBatchND) {
ConvertSpaceToBatchNDOperator(
model, static_cast<const SpaceToBatchNDOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kBatchToSpaceND) {
ConvertBatchToSpaceNDOperator(
model, static_cast<const BatchToSpaceNDOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kPad) {
ConvertPadOperator(model, static_cast<const PadOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kPadV2) {
ConvertPadV2Operator(model, static_cast<const PadV2Operator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kStridedSlice) {
ConvertStridedSliceOperator(
model, static_cast<const StridedSliceOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kMean) {
ConvertReduceOperator(model, static_cast<const MeanOperator&>(src_op),
tensorflow_graph, "Mean");
} else if (src_op.type == OperatorType::kSum) {
ConvertReduceOperator(model,
static_cast<const TensorFlowSumOperator&>(src_op),
tensorflow_graph, "Sum");
} else if (src_op.type == OperatorType::kReduceProd) {
ConvertReduceOperator(model,
static_cast<const TensorFlowProdOperator&>(src_op),
tensorflow_graph, "Prod");
} else if (src_op.type == OperatorType::kReduceMin) {
ConvertReduceOperator(model,
static_cast<const TensorFlowMinOperator&>(src_op),
tensorflow_graph, "Min");
} else if (src_op.type == OperatorType::kReduceMax) {
ConvertReduceOperator(model,
static_cast<const TensorFlowMaxOperator&>(src_op),
tensorflow_graph, "Max");
} else if (src_op.type == OperatorType::kSub) {
ConvertSubOperator(model, static_cast<const SubOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kMinimum) {
ConvertTensorFlowMinimumOperator(
model, static_cast<const TensorFlowMinimumOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kMaximum) {
ConvertTensorFlowMaximumOperator(
model, static_cast<const TensorFlowMaximumOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kSqueeze) {
ConvertSqueezeOperator(model, static_cast<const SqueezeOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kSlice) {
ConvertSliceOperator(model, static_cast<const SliceOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kArgMax) {
ConvertArgMaxOperator(model, static_cast<const ArgMaxOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kArgMin) {
ConvertArgMinOperator(model, static_cast<const ArgMinOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kTopK_V2) {
ConvertTopKV2Operator(model, static_cast<const TopKV2Operator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kTranspose) {
ConvertTransposeOperator(
model, static_cast<const TransposeOperator&>(src_op), tensorflow_graph);
} else if (src_op.type == OperatorType::kShape) {
ConvertTensorFlowShapeOperator(
model, static_cast<const TensorFlowShapeOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kRank) {
ConvertRankOperator(model,
static_cast<const TensorFlowRankOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kRange) {
ConvertRangeOperator(model, static_cast<const RangeOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kPack) {
ConvertPackOperator(model, static_cast<const PackOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kFill) {
ConvertFillOperator(model, static_cast<const FillOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kFloorDiv) {
ConvertFloorDivOperator(model, static_cast<const FloorDivOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kFloorMod) {
ConvertFloorModOperator(model, static_cast<const FloorModOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kExpandDims) {
ConvertExpandDimsOperator(model,
static_cast<const ExpandDimsOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kTransposeConv) {
ConvertTransposeConvOperator(
model, static_cast<const TransposeConvOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kRandomUniform) {
ConvertRandomUniformOperator(
model, static_cast<const RandomUniformOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kEqual) {
ConvertComparisonOperator(model, src_op, "Equal", tensorflow_graph);
} else if (src_op.type == OperatorType::kNotEqual) {
ConvertComparisonOperator(model, src_op, "NotEqual", tensorflow_graph);
} else if (src_op.type == OperatorType::kGreater) {
ConvertComparisonOperator(model, src_op, "Greater", tensorflow_graph);
} else if (src_op.type == OperatorType::kGreaterEqual) {
ConvertComparisonOperator(model, src_op, "GreaterEqual", tensorflow_graph);
} else if (src_op.type == OperatorType::kLess) {
ConvertComparisonOperator(model, src_op, "Less", tensorflow_graph);
} else if (src_op.type == OperatorType::kLessEqual) {
ConvertComparisonOperator(model, src_op, "LessEqual", tensorflow_graph);
} else if (src_op.type == OperatorType::kSelect) {
ConvertSelectOperator(model, static_cast<const SelectOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kTile) {
ConvertTileOperator(model,
static_cast<const TensorFlowTileOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kPow) {
ConvertPowOperator(model, static_cast<const PowOperator&>(src_op), "Pow",
tensorflow_graph);
} else if (src_op.type == OperatorType::kAny) {
ConvertReduceOperator(model,
static_cast<const TensorFlowAnyOperator&>(src_op),
tensorflow_graph, "Any");
} else if (src_op.type == OperatorType::kLogicalAnd) {
ConvertLogicalAndOperator(model,
static_cast<const LogicalAndOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kLogicalNot) {
ConvertLogicalNotOperator(model,
static_cast<const LogicalNotOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kOneHot) {
ConvertOneHotOperator(model, static_cast<const OneHotOperator&>(src_op),
tensorflow_graph);
} else if (src_op.type == OperatorType::kLogicalOr) {
ConvertLogicalOrOperator(model,
static_cast<const LogicalOrOperator&>(src_op),
"LogicalOr", tensorflow_graph);
} else if (src_op.type == OperatorType::kCTCBeamSearchDecoder) {
ConvertCTCBeamSearchDecoderOperator(
model, static_cast<const CTCBeamSearchDecoderOperator&>(src_op),
"CTCBeamSearchDecoder", tensorflow_graph);
} else if (src_op.type == OperatorType::kUnpack) {
ConvertUnpackOperator(model, static_cast<const UnpackOperator&>(src_op),
"Unpack", tensorflow_graph);
} else if (src_op.type == OperatorType::kZerosLike) {
ConvertZerosLikeOperator(
model, static_cast<const TensorFlowZerosLikeOperator&>(src_op),
"ZerosLike", tensorflow_graph);
} else if (src_op.type == OperatorType::kReverseV2) {
ConvertReverseV2Operator(model,
static_cast<const ReverseV2Operator&>(src_op),
"Reverse_V2", tensorflow_graph);
} else if (src_op.type == OperatorType::kReverseSequence) {
ConvertReverseSequenceOperator(
model, static_cast<const ReverseSequenceOperator&>(src_op),
tensorflow_graph);
} else {
LOG(FATAL) << "Unhandled operator type " << OperatorTypeName(src_op.type);
}
}