OpenVINO™ 低精度のトランスフォーメーション#

// 関数が量子化されているかチェックして、量子化されていない関数の LPT トランスフォーメーションを無視し、モデルの読み込みを高速化 
const bool useLpt = ov::pass::low_precision::LowPrecision::isFunctionQuantized(model); 
auto defaultPrecisions = 
    useLpt ? ov::pass::low_precision::precision_set::get_int8_support() : 
std::vector<ov::element::Type>{}; 
if (useLpt) { 
    // 逆量子化サブグラフの定数畳み込みを無効にして、LPT で処理できるようにします 
    manager.register_pass<ov::pass::MarkDequantizationSubgraph>(defaultPrecisions); 
} 

// OpenVINO の一般的なトランスフォーメーションはここで行われます 

if (useLpt) { 
    // 不要な FP16 から FP32 への変換を防ぐために減算定数を INT8 に変換 
    manager.register_pass<ov::pass::low_precision::ConvertSubtractConstant>(defaultPrecisions); 
} 

// OpenVINO の一般的なトランスフォーメーションはここで行われます 
}
if (useLpt) { 
    // 変換がサポートされていないケース FakeQuantize -> 変換 -> 変換 -> 減算 -> 乗算して単一の FakeQuantize に変換 
    pass_config->set_callback<ov::pass::ConvertQuantizeDequantize>([&defaultPrecisions](const std::shared_ptr<const ov::Node> &node) -> bool { 
        return 
ov::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node, defaultPrecisions); 
    }); 

    // サポートされていないケース FakeQuantize -> 変換 -> 変換 -> 減算 -> 乗算して単一の FakeQuantize に変換 
    pass_config->set_callback<ov::pass::ConvertSubtract>([&defaultPrecisions](const std::shared_ptr<const ov::Node> &node) -> bool { 
        return 
ov::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(node, defaultPrecisions); 
    }); 
} 

manager.run_passes(model);

using namespace ov::pass::low_precision; 
if (useLpt) { 
    // 低精度トランスフォーメーション・プラグイン固有の設定: 制限の定義 
    auto supportedPrecisions = std::vector<PrecisionsRestriction>({ 
        PrecisionsRestriction::create<ov::opset1::Convolution>({ 
            {{0}, {ov::element::u8}}, 
            {{1}, {ov::element::i8}}, 
        }), 
        PrecisionsRestriction::create<ov::opset1::ConvolutionBackpropData>( 
            {{{0}, {ov::element::u8, ov::element::i8}}, {{1}, {ov::element::i8}}}), 
        PrecisionsRestriction::create<ov::opset1::GroupConvolution>( 
            {{{0}, {ov::element::u8}}, {{1}, {ov::element::i8}}}), 
        PrecisionsRestriction::create<ov::opset1::Multiply>({ 
            {{0}, {ov::element::u8}}, 
            {{1}, {ov::element::i8}}, 
        }), 
    }); 

    // 低精度トランスフォーメーション・プラグイン固有の設定: テンソルごとの量子化操作の定義 
    auto perTensorQuantization = std::vector<QuantizationGranularityRestriction>({ 
        QuantizationGranularityRestriction::create<ov::opset1::Convolution>({0}), 
        QuantizationGranularityRestriction::create<ov::opset1::ConvolutionBackpropData>({0}) 
    }); 

    // パスマネージャーにおける低精度トランスフォーメーションのインスタンス化と登録 
    ov::pass::Manager lptManager; 
    lptManager.register_pass<ov::pass::low_precision::LowPrecision>(supportedPrecisions, perTensorQuantization); 

    // 低精度トランスフォーメーション・プラグイン固有の設定: 変換コールバックの定義 
    lptManager.get_pass_config()->set_callback<MarkupPrecisions>([](const std::shared_ptr<const ov::Node>& node) -> bool { 
        if (const auto multiply = std::dynamic_pointer_cast<const ov::opset1::Multiply>(node)) { 
            return 
!MultiplyToGroupConvolutionTransformation::canBeTransformedToGroupConvolution(multiply); 
        } 
        return false; 
    }); 
    lptManager.get_pass_config()->set_callback<ConvolutionBackpropDataTransformation>([&defaultPrecisions](const std::shared_ptr<const ov::Node>& node) -> bool { 
        return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) || WeightableLayerTransformation::isAsymmetricOnWeights(node); 
    }); 
    lptManager.get_pass_config()->set_callback<MultiplyToGroupConvolutionTransformation>([](const std::shared_ptr<const ov::Node>& node) -> bool { 
        return MultiplyToGroupConvolutionTransformation::isDynamicOrScalar(node); 
    }); 

    // 低精度トランスフォーメーションの実行 
    lptManager.run_passes(model); 
}

ov::pass::Manager deviceSpecificManager; 
deviceSpecificManager.register_pass<ov::pass::device::ConvertOpSet1ToDeviceSpecific>(); 
deviceSpecificManager.run_passes(model);

auto supportedPrecisions = std::vector<PrecisionsRestriction>({ 
    PrecisionsRestriction::create<ov::opset1::Convolution>({ 
        {{0}, {ov::element::u8}}, 
        {{1}, {ov::element::i8}}, 
    }), 
}); 

ov::pass::Manager lptManager; 
lptManager.register_pass<ov::pass::low_precision::LowPrecision>(supportedPrecisions); 
lptManager.run_passes(model);

using namespace ov::pass::low_precision; 

const std::vector<PrecisionsRestriction> emptyRestrictions; 

auto perTensorQuantization = std::vector<QuantizationGranularityRestriction>({ 
    QuantizationGranularityRestriction::create<ov::opset1::Convolution>({0}) 
}); 

ov::pass::Manager lptManager; 
lptManager.register_pass<ov::pass::low_precision::LowPrecision>(emptyRestrictions, perTensorQuantization); 
lptManager.run_passes(model);

using namespace ov::pass::low_precision; 
ov::pass::Manager lptManager; 

lptManager.register_pass<ov::pass::low_precision::LowPrecision>(); 
lptManager.get_pass_config()->set_callback<ConvolutionBackpropDataTransformation>([&defaultPrecisions](const std::shared_ptr<const ov::Node>& node) -> bool { 
    return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) || WeightableLayerTransformation::isAsymmetricOnWeights(node); 
}); 
lptManager.run_passes(model);