Task API خود را بسازید

با مجموعه‌ها، منظم بمانید ذخیره و دسته‌بندی محتوا براساس اولویت‌های شما.

TensorFlow Lite Task Library APIهای بومی/اندروید/iOS از پیش ساخته شده را در بالای همان زیرساختی که TensorFlow را انتزاع می‌کند، ارائه می‌کند. اگر مدل شما توسط کتابخانه های Task موجود پشتیبانی نمی شود، می توانید زیرساخت Task API را برای ایجاد API های سفارشی گسترش دهید.

بررسی اجمالی

زیرساخت Task API یک ساختار دو لایه دارد: لایه پایین C++ که زمان اجرای TFLite اصلی را در خود محصور می کند و لایه بالای Java/ObjC که از طریق JNI یا پوشش داخلی با لایه C++ ارتباط برقرار می کند.

پیاده‌سازی تمام منطق TensorFlow فقط در ++C هزینه را به حداقل می‌رساند، عملکرد استنتاج را به حداکثر می‌رساند و گردش کار کلی را در پلتفرم‌ها ساده می‌کند.

برای ایجاد یک کلاس Task، BaseTaskApi را گسترش دهید تا منطق تبدیل بین رابط مدل TFLite و رابط Task API را ارائه دهد، سپس از ابزارهای Java/ObjC برای ایجاد APIهای مربوطه استفاده کنید. با پنهان کردن تمام جزئیات TensorFlow، می توانید مدل TFLite را بدون هیچ دانش یادگیری ماشینی در برنامه های خود مستقر کنید.

TensorFlow Lite برخی از API های از پیش ساخته شده را برای اکثر کارهای محبوب Vision و NLP ارائه می دهد . با استفاده از زیرساخت Task API می توانید API های خود را برای کارهای دیگر بسازید.

prebuilt_task_apis
شکل 1. Task API های از پیش ساخته شده

API خود را با Task API infra بسازید

C++ API

تمام جزئیات TFLite در API اصلی پیاده سازی می شوند. با استفاده از یکی از توابع کارخانه، یک شی API ایجاد کنید و با فراخوانی توابع تعریف شده در رابط، نتایج مدل را دریافت کنید.

استفاده از نمونه

در اینجا یک مثال با استفاده از C++ BertQuestionAnswerer برای MobileBert آورده شده است.

  char kBertModelPath[] = "path/to/model.tflite";
  // Create the API from a model file
  std::unique_ptr<BertQuestionAnswerer> question_answerer =
      BertQuestionAnswerer::CreateFromFile(kBertModelPath);

  char kContext[] = ...; // context of a question to be answered
  char kQuestion[] = ...; // question to be answered
  // ask a question
  std::vector<QaAnswer> answers = question_answerer.Answer(kContext, kQuestion);
  // answers[0].text is the best answer

ساخت API

native_task_api
شکل 2. Native Task API

برای ساختن یک شی API، باید اطلاعات زیر را با گسترش BaseTaskApi

  • I/O API را تعیین کنید - API شما باید ورودی/خروجی مشابهی را در پلتفرم های مختلف نشان دهد. به عنوان مثال BertQuestionAnswerer دو رشته (std::string& context, std::string& question) را به عنوان ورودی می گیرد و یک بردار از پاسخ و احتمالات ممکن را به عنوان std::vector<QaAnswer> می گیرد. این کار با تعیین انواع مربوطه در پارامتر قالب BaseTaskApi انجام می شود. با تعیین پارامترهای الگو، تابع BaseTaskApi::Infer دارای انواع ورودی/خروجی صحیح خواهد بود. این تابع را می‌توان مستقیماً توسط کلاینت‌های API فراخوانی کرد، اما تمرین خوبی است که آن را درون یک تابع خاص مدل قرار دهید، در این مورد BertQuestionAnswerer::Answer .

    class BertQuestionAnswerer : public BaseTaskApi<
                                  std::vector<QaAnswer>, // OutputType
                                  const std::string&, const std::string& // InputTypes
                                  > {
      // Model specific function delegating calls to BaseTaskApi::Infer
      std::vector<QaAnswer> Answer(const std::string& context, const std::string& question) {
        return Infer(context, question).value();
      }
    }
    
  • ارائه منطق تبدیل بین API I/O و تانسور ورودی/خروجی مدل - با مشخص شدن انواع ورودی و خروجی، زیرکلاس ها همچنین باید توابع تایپ شده BaseTaskApi::Preprocess و BaseTaskApi::Postprocess را پیاده سازی کنند. این دو تابع ورودی و خروجی را از TFLite FlatBuffer می کنند. زیر کلاس مسئول تخصیص مقادیر از API I/O به تانسورهای I/O است. مثال پیاده سازی کامل را در BertQuestionAnswerer .

    class BertQuestionAnswerer : public BaseTaskApi<
                                  std::vector<QaAnswer>, // OutputType
                                  const std::string&, const std::string& // InputTypes
                                  > {
      // Convert API input into tensors
      absl::Status BertQuestionAnswerer::Preprocess(
        const std::vector<TfLiteTensor*>& input_tensors, // input tensors of the model
        const std::string& context, const std::string& query // InputType of the API
      ) {
        // Perform tokenization on input strings
        ...
        // Populate IDs, Masks and SegmentIDs to corresponding input tensors
        PopulateTensor(input_ids, input_tensors[0]);
        PopulateTensor(input_mask, input_tensors[1]);
        PopulateTensor(segment_ids, input_tensors[2]);
        return absl::OkStatus();
      }
    
      // Convert output tensors into API output
      StatusOr<std::vector<QaAnswer>> // OutputType
      BertQuestionAnswerer::Postprocess(
        const std::vector<const TfLiteTensor*>& output_tensors, // output tensors of the model
      ) {
        // Get start/end logits of prediction result from output tensors
        std::vector<float> end_logits;
        std::vector<float> start_logits;
        // output_tensors[0]: end_logits FLOAT[1, 384]
        PopulateVector(output_tensors[0], &end_logits);
        // output_tensors[1]: start_logits FLOAT[1, 384]
        PopulateVector(output_tensors[1], &start_logits);
        ...
        std::vector<QaAnswer::Pos> orig_results;
        // Look up the indices from vocabulary file and build results
        ...
        return orig_results;
      }
    }
    
  • ایجاد توابع کارخانه ای API - یک فایل مدل و یک OpResolver برای مقداردهی اولیه tflite::Interpreter مورد نیاز است. TaskAPIFactory توابع ابزاری را برای ایجاد نمونه های BaseTaskApi فراهم می کند.

    همچنین باید فایل های مرتبط با مدل را ارائه دهید. به عنوان مثال، BertQuestionAnswerer همچنین می تواند یک فایل اضافی برای واژگان نشانه ساز خود داشته باشد.

    class BertQuestionAnswerer : public BaseTaskApi<
                                  std::vector<QaAnswer>, // OutputType
                                  const std::string&, const std::string& // InputTypes
                                  > {
      // Factory function to create the API instance
      StatusOr<std::unique_ptr<QuestionAnswerer>>
      BertQuestionAnswerer::CreateBertQuestionAnswerer(
          const std::string& path_to_model, // model to passed to TaskApiFactory
          const std::string& path_to_vocab  // additional model specific files
      ) {
        // Creates an API object by calling one of the utils from TaskAPIFactory
        std::unique_ptr<BertQuestionAnswerer> api_to_init;
        ASSIGN_OR_RETURN(
            api_to_init,
            core::TaskAPIFactory::CreateFromFile<BertQuestionAnswerer>(
                path_to_model,
                absl::make_unique<tflite::ops::builtin::BuiltinOpResolver>(),
                kNumLiteThreads));
    
        // Perform additional model specific initializations
        // In this case building a vocabulary vector from the vocab file.
        api_to_init->InitializeVocab(path_to_vocab);
        return api_to_init;
      }
    }
    

Android API

با تعریف رابط جاوا/کاتلین و تفویض منطق به لایه C++ از طریق JNI، APIهای اندروید ایجاد کنید. Android API باید ابتدا API بومی ساخته شود.

استفاده از نمونه

در اینجا یک مثال با استفاده از Java BertQuestionAnswerer برای MobileBert آورده شده است.

  String BERT_MODEL_FILE = "path/to/model.tflite";
  String VOCAB_FILE = "path/to/vocab.txt";
  // Create the API from a model file and vocabulary file
    BertQuestionAnswerer bertQuestionAnswerer =
        BertQuestionAnswerer.createBertQuestionAnswerer(
            ApplicationProvider.getApplicationContext(), BERT_MODEL_FILE, VOCAB_FILE);

  String CONTEXT = ...; // context of a question to be answered
  String QUESTION = ...; // question to be answered
  // ask a question
  List<QaAnswer> answers = bertQuestionAnswerer.answer(CONTEXT, QUESTION);
  // answers.get(0).text is the best answer

ساخت API

android_task_api
شکل 3. Android Task API

مشابه API های بومی، برای ساخت یک شی API، کلاینت باید اطلاعات زیر را با گسترش BaseTaskApi ارائه کند، که مدیریت JNI را برای همه API های Java Task فراهم می کند.

  • I/O API را تعیین کنید - این معمولاً رابط های بومی را منعکس می کند. به عنوان مثال BertQuestionAnswerer (String context, String question) را به عنوان ورودی و خروجی List<QaAnswer> می گیرد. پیاده سازی یک تابع بومی خصوصی را با امضای مشابه فراخوانی می کند، با این تفاوت که دارای یک پارامتر اضافی long nativeHandle است که نشانگر بازگشتی از C++ است.

    class BertQuestionAnswerer extends BaseTaskApi {
      public List<QaAnswer> answer(String context, String question) {
        return answerNative(getNativeHandle(), context, question);
      }
    
      private static native List<QaAnswer> answerNative(
                                            long nativeHandle, // C++ pointer
                                            String context, String question // API I/O
                                           );
    
    }
    
  • ایجاد توابع کارخانه ای API - این نیز عملکردهای کارخانه بومی را منعکس می کند، به جز اینکه توابع کارخانه Android نیز برای دسترسی به فایل نیاز به گرفتن Context دارند. پیاده سازی یکی از ابزارهای کاربردی در TaskJniUtils را فراخوانی می کند تا شیء C++ API مربوطه را بسازد و نشانگر آن را به سازنده BaseTaskApi کند.

      class BertQuestionAnswerer extends BaseTaskApi {
        private static final String BERT_QUESTION_ANSWERER_NATIVE_LIBNAME =
                                                  "bert_question_answerer_jni";
    
        // Extending super constructor by providing the
        // native handle(pointer of corresponding C++ API object)
        private BertQuestionAnswerer(long nativeHandle) {
          super(nativeHandle);
        }
    
        public static BertQuestionAnswerer createBertQuestionAnswerer(
                                            Context context, // Accessing Android files
                                            String pathToModel, String pathToVocab) {
          return new BertQuestionAnswerer(
              // The util first try loads the JNI module with name
              // BERT_QUESTION_ANSWERER_NATIVE_LIBNAME, then opens two files,
              // converts them into ByteBuffer, finally ::initJniWithBertByteBuffers
              // is called with the buffer for a C++ API object pointer
              TaskJniUtils.createHandleWithMultipleAssetFilesFromLibrary(
                  context,
                  BertQuestionAnswerer::initJniWithBertByteBuffers,
                  BERT_QUESTION_ANSWERER_NATIVE_LIBNAME,
                  pathToModel,
                  pathToVocab));
        }
    
        // modelBuffers[0] is tflite model file buffer, and modelBuffers[1] is vocab file buffer.
        // returns C++ API object pointer casted to long
        private static native long initJniWithBertByteBuffers(ByteBuffer... modelBuffers);
    
      }
    
  • پیاده سازی ماژول JNI برای توابع بومی - همه متدهای بومی جاوا با فراخوانی یک تابع بومی مربوطه از ماژول JNI پیاده سازی می شوند. توابع کارخانه یک شی API بومی ایجاد می کنند و نشانگر آن را به عنوان یک نوع طولانی به جاوا برمی گرداند. در فراخوانی های بعدی به Java API، اشاره گر نوع طولانی به JNI ارسال می شود و به شی API اصلی بازگردانده می شود. سپس نتایج API اصلی به نتایج جاوا تبدیل می‌شوند.

    به عنوان مثال، اینگونه است که bert_question_answerer_jni پیاده سازی می شود.

      // Implements BertQuestionAnswerer::initJniWithBertByteBuffers
      extern "C" JNIEXPORT jlong JNICALL
      Java_org_tensorflow_lite_task_text_qa_BertQuestionAnswerer_initJniWithBertByteBuffers(
          JNIEnv* env, jclass thiz, jobjectArray model_buffers) {
        // Convert Java ByteBuffer object into a buffer that can be read by native factory functions
        absl::string_view model =
            GetMappedFileBuffer(env, env->GetObjectArrayElement(model_buffers, 0));
    
        // Creates the native API object
        absl::StatusOr<std::unique_ptr<QuestionAnswerer>> status =
            BertQuestionAnswerer::CreateFromBuffer(
                model.data(), model.size());
        if (status.ok()) {
          // converts the object pointer to jlong and return to Java.
          return reinterpret_cast<jlong>(status->release());
        } else {
          return kInvalidPointer;
        }
      }
    
      // Implements BertQuestionAnswerer::answerNative
      extern "C" JNIEXPORT jobject JNICALL
      Java_org_tensorflow_lite_task_text_qa_BertQuestionAnswerer_answerNative(
      JNIEnv* env, jclass thiz, jlong native_handle, jstring context, jstring question) {
      // Convert long to native API object pointer
      QuestionAnswerer* question_answerer = reinterpret_cast<QuestionAnswerer*>(native_handle);
    
      // Calls the native API
      std::vector<QaAnswer> results = question_answerer->Answer(JStringToString(env, context),
                                             JStringToString(env, question));
    
      // Converts native result(std::vector<QaAnswer>) to Java result(List<QaAnswerer>)
      jclass qa_answer_class =
        env->FindClass("org/tensorflow/lite/task/text/qa/QaAnswer");
      jmethodID qa_answer_ctor =
        env->GetMethodID(qa_answer_class, "<init>", "(Ljava/lang/String;IIF)V");
      return ConvertVectorToArrayList<QaAnswer>(
        env, results,
        [env, qa_answer_class, qa_answer_ctor](const QaAnswer& ans) {
          jstring text = env->NewStringUTF(ans.text.data());
          jobject qa_answer =
              env->NewObject(qa_answer_class, qa_answer_ctor, text, ans.pos.start,
                             ans.pos.end, ans.pos.logit);
          env->DeleteLocalRef(text);
          return qa_answer;
        });
      }
    
      // Implements BaseTaskApi::deinitJni by delete the native object
      extern "C" JNIEXPORT void JNICALL Java_task_core_BaseTaskApi_deinitJni(
          JNIEnv* env, jobject thiz, jlong native_handle) {
        delete reinterpret_cast<QuestionAnswerer*>(native_handle);
      }
    

iOS API

API های iOS را با قرار دادن یک شی API بومی در یک شی API ObjC ایجاد کنید. شی API ایجاد شده را می توان در ObjC یا Swift استفاده کرد. iOS API نیاز دارد که ابتدا API بومی ساخته شود.

استفاده از نمونه

در اینجا یک مثال با استفاده از ObjC TFLBertQuestionAnswerer برای MobileBert در سوئیفت آورده شده است.

  static let mobileBertModelPath = "path/to/model.tflite";
  // Create the API from a model file and vocabulary file
  let mobileBertAnswerer = TFLBertQuestionAnswerer.mobilebertQuestionAnswerer(
      modelPath: mobileBertModelPath)

  static let context = ...; // context of a question to be answered
  static let question = ...; // question to be answered
  // ask a question
  let answers = mobileBertAnswerer.answer(
      context: TFLBertQuestionAnswererTest.context, question: TFLBertQuestionAnswererTest.question)
  // answers.[0].text is the best answer

ساخت API

ios_task_api
شکل 4. iOS Task API

iOS API یک پوشش ساده ObjC در بالای API بومی است. API را با دنبال کردن مراحل زیر بسازید:

  • تعریف بسته بندی ObjC - یک کلاس ObjC تعریف کنید و پیاده سازی ها را به شی API اصلی مربوطه واگذار کنید. توجه داشته باشید که به دلیل ناتوانی سوئیفت در تعامل با C++، وابستگی های بومی فقط در یک فایل میلی متری ظاهر می شوند.

    • فایل .h
      @interface TFLBertQuestionAnswerer : NSObject
    
      // Delegate calls to the native BertQuestionAnswerer::CreateBertQuestionAnswerer
      + (instancetype)mobilebertQuestionAnswererWithModelPath:(NSString*)modelPath
                                                    vocabPath:(NSString*)vocabPath
          NS_SWIFT_NAME(mobilebertQuestionAnswerer(modelPath:vocabPath:));
    
      // Delegate calls to the native BertQuestionAnswerer::Answer
      - (NSArray<TFLQAAnswer*>*)answerWithContext:(NSString*)context
                                         question:(NSString*)question
          NS_SWIFT_NAME(answer(context:question:));
    }
    
    • فایل .mm
      using BertQuestionAnswererCPP = ::tflite::task::text::BertQuestionAnswerer;
    
      @implementation TFLBertQuestionAnswerer {
        // define an iVar for the native API object
        std::unique_ptr<QuestionAnswererCPP> _bertQuestionAnswerwer;
      }
    
      // Initialize the native API object
      + (instancetype)mobilebertQuestionAnswererWithModelPath:(NSString *)modelPath
                                              vocabPath:(NSString *)vocabPath {
        absl::StatusOr<std::unique_ptr<QuestionAnswererCPP>> cQuestionAnswerer =
            BertQuestionAnswererCPP::CreateBertQuestionAnswerer(MakeString(modelPath),
                                                                MakeString(vocabPath));
        _GTMDevAssert(cQuestionAnswerer.ok(), @"Failed to create BertQuestionAnswerer");
        return [[TFLBertQuestionAnswerer alloc]
            initWithQuestionAnswerer:std::move(cQuestionAnswerer.value())];
      }
    
      // Calls the native API and converts C++ results into ObjC results
      - (NSArray<TFLQAAnswer *> *)answerWithContext:(NSString *)context question:(NSString *)question {
        std::vector<QaAnswerCPP> results =
          _bertQuestionAnswerwer->Answer(MakeString(context), MakeString(question));
        return [self arrayFromVector:results];
      }
    }