Edit this page

class ngraph::pass::low_precision::FakeQuantizeDecompositionTransformation

Overview

FakeQuantizeDecompositionTransformation decomposes FakeQuantize operations to quantize (FakeQuantize with changes output intervals and low precision output type) and dequantize operations. More…

#include <fake_quantize_decomposition.hpp>

class FakeQuantizeDecompositionTransformation: public ngraph::pass::low_precision::LayerTransformation
{
public:
    // construction

    FakeQuantizeDecompositionTransformation(const Params& params = Params());

    // methods

    OPENVINO_RTTI("FakeQuantizeDecompositionTransformation", "0");

    virtual bool transform(
        TransformationContext& context,
        ngraph::pattern::Matcher& m
        );

    virtual bool isPrecisionPreserved(std::shared_ptr<Node> layer) const;
};

Inherited Members

public:
    // typedefs

    typedef DiscreteTypeInfo type_info_t;

    // classes

    class Params;
    class PrecisionDetails;

    // methods

    bool get_property(const PassPropertyMask& prop_mask) const;
    void set_name(const std::string& name);
    std::string get_name() const;
    void set_callback(const param_callback& callback);
    virtual void set_pass_config(const std::shared_ptr<PassConfig>& pass_config);
    std::shared_ptr<PassConfig> get_pass_config();
    bool m_transformation_callback(const std::shared_ptr<const Node>& node);
    bool transformation_callback(const std::shared_ptr<const Node>& node);
    virtual const type_info_t& get_type_info() const = 0;
    OPENVINO_RTTI("ov::pass::MatcherPass");
    MatcherPass& operator = (const MatcherPass&);
    bool apply(std::shared_ptr<ov::Node> node);

    template <typename T, class... Args>
    std::shared_ptr<T> register_new_node(Args&&... args);

    template <typename T>
    std::shared_ptr<T> register_new_node(const std::shared_ptr<T>& node);

    std::shared_ptr<ov::Node> register_new_node_(const std::shared_ptr<ov::Node>& node);
    const std::vector<std::shared_ptr<ov::Node>>& get_new_nodes();
    void clear_new_nodes();
    std::shared_ptr<pattern::Matcher> get_matcher();

    virtual bool transform(
        TransformationContext& context,
        ngraph::pattern::Matcher& m
        ) = 0;

    void setContext(TransformationContext \* context);
    void setUpdatePrecisions(const bool updatePrecisions);
    void setDefaultPrecisions(const std::vector<ngraph::element::Type>& defaultPrecisions);

    virtual bool canBeTransformed(
        const TransformationContext& context,
        std::shared_ptr<Node> layer
        ) const;

    bool canSubtractBeHandled(
        const std::shared_ptr<Node>& op,
        const FakeQuantizeDequantization& dequantization
        ) const;

    virtual bool isQuantized(
        const std::shared_ptr<const Node>& layer,
        const std::vector<ngraph::element::Type>& defaultPrecisions
        ) const;

    virtual bool isPrecisionPreserved(std::shared_ptr<Node> layer) const = 0;

    static bool canBeTransformedStatic(
        const std::shared_ptr<Node>& layer,
        const std::vector<ngraph::element::Type>& defaultPrecisions = precision_set::int8_support
        );

    static PrecisionDetails getPrecisionDetails(
        const size_t quantizationLevels,
        const std::vector<float>& outputLowValues,
        const std::vector<float>& outputHighValues
        );

    static PrecisionDetails getPrecisionDetails(const QuantizationDetails& quantizationDetails);

    static bool isAsymmetricQuantization(
        const std::shared_ptr<const Node>& node,
        const std::vector<ngraph::element::Type>& defaultPrecisions = precision_set::int8_support
        );

    static DataPrecision getDataPrecision(
        const std::shared_ptr<Node>& layer,
        const QuantizationDetails& quantizationDetails,
        const std::vector<element::Type>& requiredPrecisions
        );

Detailed Documentation

FakeQuantizeDecompositionTransformation decomposes FakeQuantize operations to quantize (FakeQuantize with changes output intervals and low precision output type) and dequantize operations.

For more details about the transformation, refer to FakeQuantizeDecompositionTransformation page in the Inference Engine Developer Guide.