LiteRT ऑपरेटर के वर्शन

इस दस्तावेज़ में LiteRT के ऑप वर्शनिंग स्कीमा के बारे में बताया गया है. ऑपरेटर का वर्शन इससे डेवलपर, मौजूदा ऑपरेशन में नई सुविधाएं और पैरामीटर जोड़ सकते हैं. साथ ही, यहां दी गई सुविधाओं की गारंटी दी जाती है:

• पुराने सिस्टम के साथ काम करने की सुविधा: नए LiteRT को लागू करने पर पुरानी मॉडल फ़ाइल.
• फ़ॉरवर्ड साथ काम करने की सुविधा: पुराने LiteRT को लागू करने के बाद, कन्वर्टर के नए वर्शन से बनी नई मॉडल फ़ाइल, बशर्ते कोई नई फ़ाइल न हो सुविधाओं का इस्तेमाल किया जाता है.
• साथ काम करने के तरीके की पहचान करना: अगर लागू होने वाला LiteRT का पुराना वर्शन इस्तेमाल किया जा रहा हो किसी नए मॉडल को पढ़ता है, जिसमें उस सेशन का नया वर्शन होता है जो काम नहीं करता है, तो इसे गड़बड़ी की रिपोर्ट करनी चाहिए.

उदाहरण: डेप्थवाइस कनवल्यूशन में डायलेशन जोड़ना

इस दस्तावेज़ के बाकी हिस्से में, TFLite में सेशन के वर्शन के बारे में बताया गया है. इसके लिए, यह बताया गया है कि कैसे का इस्तेमाल करें.

इस दस्तावेज़ को समझने के लिए, फैलाव की जानकारी होना ज़रूरी नहीं है. ध्यान दें कि:

• 2 नए पूर्णांक पैरामीटर जोड़े जाएंगे: dilation_width_factor और dilation_height_factor.
• पुराने डेप्थवाइस कन्वर्ज़न कर्नेल, जो फैलाव का समर्थन नहीं करते, एक जैसे हैं फैलाव के फ़ैक्टर 1 पर सेट करें.

फ़्लैटबफ़र स्कीमा बदलना

किसी सेशन में नए पैरामीटर जोड़ने के लिए, विकल्प टेबल को lite/schema/schema.fbs.

उदाहरण के लिए, डेप्थवाइज़ कॉन्वोल्यूशन की विकल्प टेबल इस तरह दिखती है:

table DepthwiseConv2DOptions {
  padding:Padding;
  stride_w:int;
  stride_h:int;
  depth_multiplier:int;
  fused_activation_function:ActivationFunctionType;
}

नए पैरामीटर जोड़ते समय:

• टिप्पणियां जोड़ें जिससे पता चलेगा कि कौनसे पैरामीटर किस वर्शन में काम करते हैं.
• जब लागू किए गए नए तरीके से, जोड़ी गई नई वैल्यू के लिए डिफ़ॉल्ट वैल्यू मिलती है पैरामीटर में, यह ठीक उसी तरह काम करना चाहिए जैसा कि पुराने तरीकों से किया गया था.

नए पैरामीटर जोड़ने के बाद, टेबल कुछ इस तरह दिखेगी:

table DepthwiseConv2DOptions {
  // Parameters for DepthwiseConv version 1 or above.
  padding:Padding;
  stride_w:int;
  stride_h:int;
  depth_multiplier:int;
  fused_activation_function:ActivationFunctionType;
  // Parameters for DepthwiseConv version 2 or above.
  dilation_w_factor:int = 1;
  dilation_h_factor:int = 1;
}

नई फ़ाइल के लिए lite/schema/schema_generated.h फ़ाइल फिर से जनरेट की जानी चाहिए स्कीमा चुनें.

C स्ट्रक्चर और कर्नेल लागू करने का तरीका बदलें

LiteRT में, कर्नेल को लागू करने के तरीके को FlatBuffer से अलग कर दिया गया है परिभाषा शामिल नहीं है. कर्नेल, इनमें परिभाषित C स्ट्रक्चर से पैरामीटर को पढ़ते हैं lite/c/builtin_op_data.h.

ओरिजनल डेप्थवाइस कन्वर्ज़न पैरामीटर इस तरह है:

typedef struct {
  TfLitePadding padding;
  int stride_width;
  int stride_height;
  int depth_multiplier;
  TfLiteFusedActivation activation;
} TfLiteDepthwiseConvParams;

FlatBuffer स्कीमा की तरह, ऐसी टिप्पणियां जोड़ें जो बताएं कि कौनसे पैरामीटर किस वर्शन से शुरू हो सकता है. इसका नतीजा यहां दिया गया है:

typedef struct {
  // Parameters for DepthwiseConv version 1 or above.
  TfLitePadding padding;
  int stride_width;
  int stride_height;
  int depth_multiplier;
  TfLiteFusedActivation activation;
  // Parameters for DepthwiseConv version 2 or above.
  int dilation_width_factor;
  int dilation_height_factor;
} TfLiteDepthwiseConvParams;

जोड़े गए नए पैरामीटर पढ़ने के लिए, कृपया कर्नेल लागू करने का तरीका भी बदलें से लिया गया है. विवरण यहां नहीं दिए गए हैं.

FlatBuffer का रीडिंग कोड बदलना

FlatBuffer को पढ़ने और C स्ट्रक्चर बनाने का लॉजिक lite/core/api/flatbuffer_conversions.cc.

यहां बताए गए तरीके से, नए पैरामीटर मैनेज करने के लिए फ़ाइल को अपडेट करें:

TfLiteStatus ParseDepthwiseConv2D(const Operator* op,
                                  ErrorReporter* error_reporter,
                                  BuiltinDataAllocator* allocator,
                                  void** builtin_data) {
  CheckParsePointerParams(op, error_reporter, allocator, builtin_data);

  SafeBuiltinDataAllocator safe_allocator(allocator);

  std::unique_ptr<TfLiteDepthwiseConvParams,
                  SafeBuiltinDataAllocator::BuiltinDataDeleter>
      params = safe_allocator.Allocate<TfLiteDepthwiseConvParams>();
  TF_LITE_ENSURE(error_reporter, params != nullptr);

  const DepthwiseConv2DOptions* schema_params =
      op->builtin_options_as_DepthwiseConv2DOptions();

  if (schema_params != nullptr) {
    params->padding = ConvertPadding(schema_params->padding());
    params->stride_width = schema_params->stride_w();
    params->stride_height = schema_params->stride_h();
    params->depth_multiplier = schema_params->depth_multiplier();
    params->activation =
        ConvertActivation(schema_params->fused_activation_function());

    params->dilation_width_factor = schema_params->dilation_w_factor();
    params->dilation_height_factor = schema_params->dilation_h_factor();
  }

  *builtin_data = params.release();
  return kTfLiteOk;
}

सेशन के वर्शन को यहां देखने की ज़रूरत नहीं है. नया तरीका लागू करने पर एक पुराने मॉडल की फ़ाइल को पढ़ता है, जिसमें फैलाव के फ़ैक्टर मौजूद नहीं हैं, तो यह 1 का इस्तेमाल इस तरह करेगा: डिफ़ॉल्ट मान सेट करता है और नया कर्नेल पुराने कर्नेल के साथ लगातार काम करेगा.

कर्नेल रजिस्ट्रेशन में बदलाव करें

म्यूटेबलओप रिज़ॉल्वर (lite/mutable_op_resolver.h में बताया गया है) से कुछ सुविधाएं मिलती हैं फ़ंक्शन का इस्तेमाल करके, ऑप कर्नेल रजिस्टर करें. कम से कम और ज़्यादा से ज़्यादा वर्शन 1 x डिफ़ॉल्ट:

void AddBuiltin(tflite::BuiltinOperator op, TfLiteRegistration* registration,
                int min_version = 1, int max_version = 1);
void AddCustom(const char* name, TfLiteRegistration* registration,
               int min_version = 1, int max_version = 1);

पहले से मौजूद ऑपरेशन, lite/kernels/register.cc में रजिस्टर किए गए हैं. इस उदाहरण में, हमने एक नया ऑप कर्नेल लागू किया है, जो DepthwiseConv2D के वर्शन 1 और 2, इसलिए हमें इस लाइन को बदलना होगा:

AddBuiltin(BuiltinOperator_DEPTHWISE_CONV_2D, Register_DEPTHWISE_CONV_2D());

इससे बदलें:

AddBuiltin(BuiltinOperator_DEPTHWISE_CONV_2D, Register_DEPTHWISE_CONV_2D(),
             /* min_version = */ 1,
             /* max_version = */ 2);

TFLite सेशन का वर्शन बदलें

इसके बाद, TFLite को सभी ज़रूरी वर्शन के तौर पर सेट करना सेशन को एक्ज़ीक्यूट करना. इस उदाहरण में, इसका मतलब है:

• जब फैलाव के फ़ैक्टर सभी 1 हों, तो वर्शन=1 को पॉप्युलेट करें.
• अगर ऐसा नहीं है, तो वर्शन=2 को पॉप्युलेट करें.

इसके ऑपरेटर के लिए GetBuiltinOperatorVersion फ़ंक्शन में बदलाव करें lite/tools/versioning/op_version.cc के लिए, DepthwiseConv2D:

case BuiltinOperator_DEPTHWISE_CONV_2D:
  auto depthwise_conv_params =
      reinterpret_cast<TfLiteDepthwiseConvParams*>(op_sig.builtin_data);
  TFLITE_DCHECK(depthwise_conv_params != nullptr);
  if (depthwise_conv_params->dilation_width_factor != 1 ||
       depthwise_conv_params->dilation_height_factor != 1) {
    return 2;
  }
  return 1;

ऑपरेटर वर्शन मैप अपडेट करें

आखिरी चरण, ऑपरेटर वर्शन मैप में नए वर्शन की जानकारी जोड़ना है. यह चरण की ज़रूरत होती है, क्योंकि हमें मॉडल की न्यूनतम ज़रूरी संख्या जनरेट करनी होती है इस वर्शन मैप पर आधारित रनटाइम वर्शन है.

ऐसा करने के लिए आपको lite/tools/versioning/runtime_version.cc.

इस उदाहरण में, आपको op_version_map में यह एंट्री जोड़नी होगी:

{ {BuiltinOperator_DEPTHWISE_CONV_2D, 2}, %CURRENT_RUNTIME_VERSION%}

जहां %CURRENT_RUNTIME_VERSION%, रनटाइम के मौजूदा वर्शन से जुड़ा है tensorflow/core/public/version.h में परिभाषित.

डेलिगेशन की सुविधा लागू करना

LiteRT, डेलिगेशन एपीआई उपलब्ध कराता है. इसकी मदद से, ऑपरेशन का ऐक्सेस किसी और को देने की सुविधा हार्डवेयर बैकएंड. डेलिगेट के Prepare फ़ंक्शन में, देखें कि वर्शन डेलिगेशन कोड में हर नोड के लिए काम करता है.

const int kMaxVersion = 1;
TfLiteNode* node;
TfLiteRegistration* registration = nullptr;
TF_LITE_ENSURE_STATUS(context->GetNodeAndRegistration(context, node_index, &node, &registration));

if (registration->version > kMaxVersion) {
  // Reject the node if the version isn't supported.
}

यह इसलिए ज़रूरी है, भले ही डेलिगेशन सिर्फ़ वर्शन 1 ऑपरेशन का समर्थन करता हो, इसलिए उच्च वर्शन सेशन पाने पर डेलिगेशन की वजह से साथ काम न करने वाले सिस्टम का पता लगाया जा सकता है.