TensorFlow Lite ऑपरेटर संस्करण

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

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

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

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

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

  • 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 पुनः जेनरेट किया जाना चाहिए।

सी संरचनाएं और कर्नेल कार्यान्वयन बदलें

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

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

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;

कृपया सी संरचनाओं से नए जोड़े गए मापदंडों को पढ़ने के लिए कर्नेल कार्यान्वयन को भी बदलें। विवरण यहां छोड़े गए हैं।

फ़्लैटबफ़र रीडिंग कोड बदलें

फ़्लैटबफ़र को पढ़ने और सी संरचना तैयार करने का तर्क 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 का उपयोग करेगा, और नया कर्नेल पुराने कर्नेल के साथ लगातार काम करेगा।

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

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