TensorFlow लाइट ऑपरेटर संस्करण

यह दस्तावेज़ TensorFlow Lite के ऑप वर्जनिंग स्कीमा का वर्णन करता है। Op versioning डेवलपर्स को मौजूदा ops में नई कार्यक्षमता और पैरामीटर जोड़ने में सक्षम बनाता है। इसके अलावा, यह निम्नलिखित की गारंटी देता है:

• पश्चगामी संगतता: नए TensorFlow Lite कार्यान्वयन को एक पुरानी मॉडल फ़ाइल को संभालना चाहिए।
• आगे की संगतता: पुराने TensorFlow Lite कार्यान्वयन को कनवर्टर के नए संस्करण द्वारा निर्मित एक नई मॉडल फ़ाइल को संभालना चाहिए, जब तक कि कोई नई सुविधाओं का उपयोग नहीं किया जाता है।
• फ़ॉरवर्ड इन-कम्पैटिबिलिटी डिटेक्शन: यदि एक पुराना TensorFlow लाइट कार्यान्वयन एक नया मॉडल पढ़ता है जिसमें एक ऑप का नया संस्करण शामिल है जो समर्थित नहीं है, तो उसे त्रुटि की रिपोर्ट करनी चाहिए।

उदाहरण: गहराई से कनवल्शन में फैलाव जोड़ना

इस दस्तावेज़ का शेष भाग टीएफलाइट में ऑप वर्जनिंग की व्याख्या करता है, जिसमें दिखाया गया है कि डेप्थवाइज कनवल्शन ऑपरेशन में फैलाव मापदंडों को कैसे जोड़ा जाए।

इस दस्तावेज़ को समझने के लिए फैलाव के ज्ञान की आवश्यकता नहीं है। ध्यान दें कि:

• 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 संरचना और कर्नेल कार्यान्वयन बदलें

TensorFlow Lite में, कर्नेल कार्यान्वयन को FlatBuffer परिभाषा से अलग किया गया है। कर्नेल lite/c/builtin_op_data.h में परिभाषित सी संरचनाओं से पैरामीटर पढ़ते हैं।

मूल गहराई से कनवल्शन पैरामीटर इस प्रकार है:

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

फ़्लैटबफ़र स्कीमा के साथ, टिप्पणियों को जोड़ें जो इंगित करता है कि कौन से पैरामीटर किस संस्करण से शुरू होने का समर्थन करते हैं। परिणाम नीचे देखा गया है:

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 को पढ़ने और 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;
}

यहां op संस्करण की जांच करने की आवश्यकता नहीं है। जब नया कार्यान्वयन एक पुरानी मॉडल फ़ाइल को पढ़ता है जहां फैलाव कारक गायब हैं, तो यह डिफ़ॉल्ट मान के रूप में 1 का उपयोग करेगा, और नया कर्नेल पुराने कर्नेल के साथ लगातार काम करेगा।

कर्नेल पंजीकरण बदलें

MutableOpResolver ( lite/mutable_op_resolver.h में परिभाषित) सेशन कर्नेल को पंजीकृत करने के लिए कुछ कार्य प्रदान करता है। न्यूनतम और अधिकतम संस्करण डिफ़ॉल्ट रूप से 1 हैं:

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 सेशन संस्करण बदलें

अगला कदम टीएफलाइट को उस न्यूनतम संस्करण को पॉप्युलेट करना है जो ऑप को निष्पादित करने के लिए आवश्यक है। इस उदाहरण में, इसका अर्थ है:

• संस्करण = 1 को पॉप्युलेट करें जब फैलाव कारक सभी 1 हों।
• आबाद संस्करण = 2 अन्यथा।

DepthwiseConv2D के मामले में नया संस्करण जोड़कर lite/tools/versioning/op_version.cc DepthwiseConv2D ऑपरेटर के लिए GetBuiltinOperatorVersion फ़ंक्शन को संशोधित करें:

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 में परिभाषित वर्तमान रनटाइम संस्करण से मेल खाता है।

प्रतिनिधिमंडल कार्यान्वयन

TensorFlow Lite एक डेलिगेशन API प्रदान करता है जो ऑप्स को हार्डवेयर बैकएंड में सौंपने में सक्षम बनाता है। प्रतिनिधि के 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 ऑप्स का समर्थन करता हो, इसलिए उच्च संस्करण सेशन प्राप्त करते समय प्रतिनिधिमंडल असंगतता का पता लगा सकता है।